CN107294656B - Depth-first-based distributed arithmetic code decoding method - Google Patents

Depth-first-based distributed arithmetic code decoding method Download PDF

Info

Publication number
CN107294656B
CN107294656B CN201710419222.0A CN201710419222A CN107294656B CN 107294656 B CN107294656 B CN 107294656B CN 201710419222 A CN201710419222 A CN 201710419222A CN 107294656 B CN107294656 B CN 107294656B
Authority
CN
China
Prior art keywords
path
node
decoder
pause
spaths
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Expired - Fee Related
Application number
CN201710419222.0A
Other languages
Chinese (zh)
Other versions
CN107294656A (en
Inventor
方勇
崔华
王璇
关琦
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Changan University
Original Assignee
Changan University
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Changan University filed Critical Changan University
Priority to CN201710419222.0A priority Critical patent/CN107294656B/en
Publication of CN107294656A publication Critical patent/CN107294656A/en
Application granted granted Critical
Publication of CN107294656B publication Critical patent/CN107294656B/en
Expired - Fee Related legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L1/00—Arrangements for detecting or preventing errors in the information received
    • H04L1/004—Arrangements for detecting or preventing errors in the information received by using forward error control
    • H04L1/0045—Arrangements at the receiver end
    • H04L1/0054—Maximum-likelihood or sequential decoding, e.g. Viterbi, Fano, ZJ algorithms
    • H—ELECTRICITY
    • H03—ELECTRONIC CIRCUITRY
    • H03M—CODING; DECODING; CODE CONVERSION IN GENERAL
    • H03M7/00—Conversion of a code where information is represented by a given sequence or number of digits to a code where the same, similar or subset of information is represented by a different sequence or number of digits
    • H03M7/30—Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction
    • H03M7/40—Conversion to or from variable length codes, e.g. Shannon-Fano code, Huffman code, Morse code
    • H03M7/4006—Conversion to or from arithmetic code

Abstract

The invention discloses a depth-first-based distributed arithmetic code decoding method, which comprises the following steps: a data structure and global variables; a depth-first decoding summary; searching a single path; decoder behavior at the fork node; compressing the end node pause path list; releasing an online memory; selecting an optimal pause path; and (4) terminating the conditions. Depth-first decoding performs better on short codes compared to existing breadth-first decoding.

Description

Depth-first-based distributed arithmetic code decoding method
Technical Field
The invention relates to a depth-first decoding method, in particular to a depth-first-based distributed arithmetic code decoding method.
Background
The distributed information source coding is based on Slepian-Wolf theory and Wyner-Ziv theory, and is one of hot research directions in the coding field. Distributed Arithmetic Coding (DAC) is based on the basic theory of Distributed source Coding, and a Coding scheme generated by introducing Arithmetic Coding as a codec core has been widely accepted and applied because it exhibits performance close to the compression limit when processing small data blocks. The distributed arithmetic code forms an incomplete binary decoding tree as decoding progresses due to overlapping regions. The conventional distributed arithmetic code decoding scheme is implemented based on a breadth-first search, and a hamming distance between a minimum full path and side information is unknown before reaching a leaf node, so that a large number of nodes need to be accessed to implement a full search of a decoding tree. Meanwhile, in order to prevent overflow, the decoder needs to allocate space for the end nodes of all paths, and the memory can be released after decoding is finished, which causes resource waste. Aiming at the problem, the invention provides a depth-first decoder, which makes up the defects of the traditional decoder.
Disclosure of Invention
The invention aims to provide a depth-first-based distributed arithmetic code decoding method.
The specific technical scheme is as follows:
a depth-first based distributed arithmetic code decoding method comprises the following steps:
1) data structure and global variables: implementing the depth-first algorithm requires defining a data structure for a node for the DAC, including the following members:
i.e. the level of the node, i.e. the path length to the end of the node.
l, h and c three shaping variables with the same precision. l and h are the upper and lower limits of the node, respectively. c is used to buffer the amount of bits from the DAC bit stream.
p-the DAC bit stream is read into the position of the next bit of c.
d: the hamming distance of the path between the end of the node and the side information.
m: the overall metric of the path at the end of the node.
child0, child1 and parent: these three pointers point to the left branch node, the right branch node, and the parent node of the node, respectively.
Furthermore, the following global variables are required:
bst: the best complete path to the leaf node.
spaths: an array of pointers whose elements point to the end node's pause path.
nsp: the number of elements occupied in spaths.
dmin: the hamming distance between the minimum complete path and the side information.
If the Hamming distance between a path and side information is equal to or greater than dminIndicating that this path is not possible; otherwise we say this is possible.
2) Depth-first decoding summary: initially, the root node is according to u0And (4) creating. The decoder then repeatedly calls a single path search function, the compact _ list function, which removes the end nodes of the pause path from the spaths that are not possible, the wakeup _ path function, and selects the best pause path from the spaths to create a new path until the condition is finally satisfied to end the loop. Finally, the information source
Figure BDA0001314508210000021
The optimal estimate of (c) is obtained by tracing back bst.
3) Single-path search: traversing from a level i section sThe point (which may not be the root node) starts. The decoder first computes u by s.l, s.h, and s.c, and then decides the current symbol by u
Figure BDA0001314508210000031
If it is not
Figure BDA0001314508210000032
Equal to 0 or 1, side information and at node s
Figure BDA0001314508210000033
The Hamming distance between paths where child nodes end will be
Figure BDA0001314508210000034
If it is not
Figure BDA0001314508210000035
Is obviously that
Figure BDA0001314508210000036
Terminating the path at the child node is promising, so that the decoder creates s
Figure BDA0001314508210000037
Subnode and redirect s to it
Figure BDA0001314508210000038
A child node of (1); otherwise, the decoder calls the prune _ path function to prune the path ending at the s-node and terminate the pass through. This problem is compounded if u falls within the overlap interval, so the branch function is defined to describe the behavior of the decoder at the cross-point. If a transfer is not terminated to a leaf node, it is called a complete transfer, which means that the complete path ending at the leaf node must be the best full path so far, and therefore the hamming distance d between the minimum full path and the side information must be updatedmin。
4) Decoder behavior at the fork node: if s is a fork node (unless this path is terminated), at least one s sub-path is feasible, i.e., if the left sub-path of s is not feasible, its right sub-path must be feasible, and vice versa. If all sub-paths of s are feasible, the corresponding sub-nodes will be better, i.e. for better overall index, the sub-paths will be selected to continue the path, however, the unselected branches will be stored in the spaths array.
5) Node compression list of pause path: after each full path, the decoder updates d with the hamming distance between the full path and the side information at the end of dstmin. Then use the new dminThe decoder compresses the spaths array by removing the node pointers to the end nodes of the unconditional pause path: if the Hamming distance between the path and the side information is equal to or greater than dminThen the path will be pruned and its node pointer to its end node will be removed from the spaths array.
6) Online memory release: the list is compressed and the memory allocated to the garbage path is partially freed by pruning the path function through a function call, by iteratively deleting the end node of the unconditional path back until the end node is shared with other paths.
7) Selecting the best pause path: after calling the compact list function, all elements in the spaths will point to the end node of the possible pause path. The decoder then calls the wave _ path function to select the best pause path from the pause list based on the overall path metric. Once the optimal pause path is determined, a new traversal will be started from its end node, while the node pointer to its end node will be removed from the spaths.
8) Termination conditions were as follows: the termination condition of the depth-first decoder depends on the actual constraints. If the decoder is not complexity constrained, the termination condition may be the number of pause paths that it is desired to store: if nsp is 0, i.e. spaths is empty, decoding is stopped, which means that the DAC tree has been completely searched. If the decoder is constrained by complexity, the number of nodes created can be used as a termination condition: if the number of created nodes exceeds a threshold, decoding is stopped.
Further, in step 5), if the number of possible pause paths exceeds the spaths size, a memory overflow will occur. In this case, the decoder orders the possible pause paths according to their overall metric and discards some bad ones, but this carries the risk of incorrect pruning of the correct paths.
Further, in step 6), the path is known
Figure BDA0001314508210000041
After it is impossible, the prune path function iteratively deletes nodes in the dashed ellipse backwards, and eventually stops at the path
Figure BDA0001314508210000042
And sharing the nodes.
Compared with the prior art, the invention has the beneficial effects that:
depth-first decoding performs better on short codes compared to existing breadth-first decoding.
Drawings
FIG. 1 is a schematic illustration of depth-first decoding;
FIG. 2 is pseudo code of a DFD based DAC;
FIG. 3 is pseudo code of a pass function;
FIG. 4 is pseudo code of a branch function;
FIG. 5 is a diagram of fixed code length n, code rate R and source side information cross probability ε to calculate the effect of tail length t, where FIG. 5(a) the difference ratio and frame error ratio of the two decoders, and FIG. 5(b) the number of access nodes of the two decoders;
FIG. 6 is a diagram of the fixed tail length t, the code rate R and the cross probability ε of the source side information to take into account the effect of the code length n, where FIG. 6(a) the difference ratio and frame error ratio of the two decoders, and FIG. 6(b) the number of access nodes of the two decoders;
fig. 7 shows the fixed code length n, tail length t and code rate R to take into account the influence of the source side information crossing probability epsilon, where fig. 7(a) shows the difference ratio and frame error ratio of the two decoders, and fig. 7(b) shows the number of access nodes of the two decoders.
Detailed Description
The technical solution of the present invention will be described in further detail with reference to the accompanying drawings and specific embodiments.
Depth-first based distributed arithmetic code decoding principle
Depth-first decoding breaks down distributed arithmetic code decoding into a process of delivery, starting from some non-leaf nodes (only initially from the root node), and usually ending with one leaf node. During each cross node, the decoder always selects the most likely child node, i.e. with the greater overall metric, while storing the other node in the list. We call the path that ends where the stored child node ends as suspended. This is repeated until a leaf node is reached or some abort condition is met, this entire process being referred to as a pass. The decoder then selects the best, i.e. the pause path with the largest total metric from the list of pause paths to resume its search, which will trigger a new pass, repeating this act of selecting resume until some termination condition is met. Finally, the full path is preferably the estimated output of the source.
A schematic diagram of depth-first decoding can be demonstrated by fig. 1. Suppose the side information is
Figure BDA0001314508210000051
The initial traversal follows a complete path
Figure BDA0001314508210000052
The process is carried out. After the initial traversal, the decoder records the hamming distance of the path side information:
Figure BDA0001314508210000053
along the path
Figure BDA0001314508210000054
There are three diverging nodes, thus suspending three unequal length paths: (
Figure BDA0001314508210000055
And
Figure BDA0001314508210000056
. The forking pick/store node is based on the total path metric rather than the side information. Thus, the 1-branch is selected at the first fork node, and the path
Figure BDA0001314508210000057
Is suspended. After the initial pass, the decoder selects the best, i.e. with the largest total metric, pause path
Figure BDA0001314508210000058
And triggers a new path. Second time along the path
Figure BDA0001314508210000059
Go forward and due to the Hamming distance between the path and the side information
Figure BDA00013145082100000510
But is prematurely terminated. During the second pass, the path
Figure BDA00013145082100000511
Is suspended. Assignment to early termination path
Figure BDA00013145082100000512
Can be partially freed because the last three nodes (marked with dashed lines) belong only to the path
Figure BDA00013145082100000513
Distributed arithmetic code decoder implementation based on depth-first algorithm
1) Data structure and global variables: implementing the depth-first algorithm requires defining a data structure for a node for the DAC, including the following members:
i.e. the level of the node, i.e. the path length to the end of the node.
l, h and c three shaping variables with the same precision. l and h are the upper and lower limits of the node, respectively. c is used to buffer the amount of bits from the DAC bit stream.
p-the DAC bit stream is read into the position of the next bit of c.
d: the hamming distance of the path between the end of the node and the side information.
m: the overall metric of the path at the end of the node.
child0, child1 and parent: these three pointers point to the left branch node, the right branch node, and the parent node of the node, respectively.
Furthermore, the following global variables are required:
bst: the best complete path to the leaf node.
spaths: an array of pointers whose elements point to the end node's pause path.
nsp: the number of elements occupied in spaths.
dmin: the hamming distance between the minimum complete path and the side information.
If the Hamming distance between a path and side information is equal to or greater than dminIndicating that this path is not possible; otherwise we say this is possible.
2) Depth-first decoding summary: shown in fig. 2 is pseudo code of a depth first decoding algorithm. Initially, the root node is according to u0And (4) creating. The decoder then repeatedly calls a single path search function, the compact _ list function, which removes the end nodes of the pause path from the spaths that are not possible, the wakeup _ path function, and selects the best pause path from the spaths to create a new path until the condition is finally satisfied to end the loop. Finally, the information source
Figure BDA0001314508210000061
The optimal estimate of (c) is obtained by tracing back bst.
3) Single-path search: FIG. 3 shows pseudo code for the pass function. Traversal starts with an s-node at level i (which may not be the root node). The decoder first computes u by s.l, s.h, and s.c, and then decides the current symbol by u
Figure BDA0001314508210000071
If it is not
Figure BDA0001314508210000072
Equal to 0 or 1, side information and at node s
Figure BDA0001314508210000073
The Hamming distance between paths where child nodes end will be
Figure BDA0001314508210000074
If it is not
Figure BDA0001314508210000075
Is obviously that
Figure BDA0001314508210000076
Terminating the path at the child node is promising, so that the decoder creates s
Figure BDA0001314508210000077
Subnode and redirect s to it
Figure BDA0001314508210000078
A child node of (1); otherwise, the decoder calls the prune _ path function to prune the path ending at the s-node and terminate the pass through. This problem is compounded if u falls within the overlap interval, so the branch function is defined to describe the behavior of the decoder at the cross-point. If a transfer is not terminated to a leaf node, it is called a complete transfer, which means that the complete path ending at the leaf node must be the best full path so far, and therefore the hamming distance d between the minimum full path and the side information must be updatedmin。
4) Decoder behavior at the fork node: as shown in fig. 4, is a pseudo code of a branching function. If s is a fork node (unless this path is terminated), at least one s sub-path is feasible, i.e., if the left sub-path of s is not feasible, its right sub-path must be feasible, and vice versa. If all sub-paths of s are feasible, the corresponding sub-nodes will be better, i.e. for better overall index, the sub-paths will be selected to continue the path, however, the unselected branches will be stored in the spaths array.
5) Node compression list of pause path: after each full path, the decoder updates d with the hamming distance between the full path and the side information at the end of dstmin. Then use the new dminThe decoder compresses the spaths array by removing the node pointers to the end nodes of the unconditional pause path: if the Hamming distance between the path and the side information is equal to or greater than dminThen the path will be pruned and its node pointer to its end node will be removed from the spaths array. If the number of possible pause paths exceeds the spaths size, a memory overflow will occur. In this case, the decoder orders the possible pause paths according to their overall metric and discards some bad ones, but this carries the risk of incorrect pruning of the correct paths.
6) Online memory release: the list is compressed and the memory allocated to the garbage path is partially freed by pruning the path function through a function call, by iteratively deleting the end node of the unconditional path back until the end node is shared with other paths. In knowing the path
Figure BDA0001314508210000081
After it is impossible, the prune path function iteratively deletes nodes in the dashed ellipse back and eventually stops at the and path
Figure BDA0001314508210000082
And sharing the nodes.
7) Selecting the best pause path: after calling the compact list function, all elements in the spaths will point to the end node of the possible pause path. The decoder then calls the wave _ path function to select the best pause path from the pause list based on the overall path metric. Once the optimal pause path is determined, a new traversal will be started from its end node, while the node pointer to its end node will be removed from the spaths.
8) Termination conditions were as follows: the termination condition of the depth-first decoder depends on the actual constraints. If the decoder is not complexity constrained, the termination condition may be the number of pause paths that it is desired to store: if nsp is 0, i.e. spaths is empty, decoding is stopped, which means that the DAC tree has been completely searched. If the decoder is constrained by complexity, the number of nodes created can be used as a termination condition: if the number of created nodes exceeds a threshold, decoding is stopped.
The depth-first decoding is then compared to the existing breadth-first decoding. For a fair comparison, an equivalence constraint is imposed on both decoders: if the maximum number of allowed paths for breadth-first decoding is set to K, the number of maximum subject nodes that depth-first decoding allows access is set to (n-t) K, where K is 256.
The influence of the tail length t is calculated by considering the fixed code length n, the code rate R and the information source side information cross probability epsilon. As shown in fig. 5(a), when subject to the equivalence constraint, the two decoders perform very similarly to each other for different tail lengths t. At the same time, the number of body nodes actually visited by both decoders is also calculated. In fig. 5(b), since the end nodes are not counted, the number of body nodes actually visited for breadth-first decoding decreases relative to t. In contrast, the number of body nodes actually visited by depth-first decoding continuously rises with respect to t. As can be seen from fig. 5(b), to achieve the same FER and SER, for small t, depth first decoding accesses far fewer nodes. However, as t increases, the advantage of depth-first decoding over breadth-first decoding will fade away, and finally, when t is large enough, the latter will exhibit better performance.
Then, the influence of the code length n is considered by fixing the tail length t, the code rate R and the cross probability epsilon of the information source side information. As shown in fig. 6(a), the two decoders perform very similarly for different code lengths n when subject to the equivalence constraint. As can be seen from fig. 6(b), for both decoders, the number of actually accessed nodes rises continuously with respect to n, with depth first decoding being faster. Thus, depth-first decoding performs better for short codes but worse for long codes than breadth-first decoding.
And finally, considering the influence of the source side information cross probability epsilon through the fixed code length n, the tail length t and the code rate R. As shown in fig. 7(a), the cross probability epsilon of two decoders for different source-side information performs very similarly when subject to the equivalence constraint. As can be seen from fig. 7(b), epsilon has no effect on the complexity of breadth-first decoding, while the complexity of depth-first decoding rises as epsilon increases. Thus, if the quality of the side information is high, depth-first decoding is better than breadth-first decoding, but if the quality of the side information is poor, depth-first decoding is worse than breadth-first decoding.
The above description is only a preferred embodiment of the present invention, and the scope of the present invention is not limited thereto, and any simple modifications or equivalent substitutions of the technical solutions that can be obviously obtained by those skilled in the art within the technical scope of the present invention are within the scope of the present invention.

Claims (3)

1. A depth-first based distributed arithmetic code decoding method is characterized by comprising the following steps:
1) data structure and global variables: implementing the depth-first algorithm requires defining a data structure for a node for the DAC, including the following members:
i, the grade of the node, namely the path length to the end of the node;
l, h and c are three shaping variables with the same precision; l and h are the upper and lower limits of the node, respectively; c to buffer the amount of bits from the DAC bit stream;
p, reading the DAC bit stream into the position of the next bit of c;
d: the hamming distance of the path between the end of the node and the side information;
m: an overall metric of the path at which the node ends;
child0, child1 and parent: the three pointers point to a left branch node, a right branch node and a parent node of the node respectively;
DAC is distributed arithmetic code;
furthermore, the following global variables are required:
bst: an optimal complete path pointing to a leaf node;
spaths: an array of pointers whose elements point to the paused path of the end node;
nsp: the number of elements occupied in the spaths;
dmin: the hamming distance between the minimum complete path and the side information;
if the Hamming distance between a path and side information is equal to or greater than dminIndicating that this path is not possible; otherwise we say this is possible;
2) depth-first decoding summary: initially, the root node is according to u0Creating; then the decoder repeatedly calls a single path search function, a compact _ list function, deletes the end node of the pause path which is impossible from the spaths, a wakeup _ path function, and selects the best pause path from the spaths to generate a new path until the condition is finally met to finish the cycle; finally, the information source
Figure FDA0002556970870000021
The optimal estimate of (b) is obtained by tracing back bst;
3) single-path search: traversing starts from an s node with the level i; the decoder first computes u by s.l, s.h, and s.c, and then decides the current symbol by u
Figure FDA0002556970870000022
If it is not
Figure FDA0002556970870000023
Equal to 0 or 1, side information and at node s
Figure FDA0002556970870000024
The Hamming distance between paths where child nodes end will be
Figure FDA0002556970870000025
If it is not
Figure FDA0002556970870000026
Is obviously that
Figure FDA0002556970870000027
Terminating the path at the child node is promising, so that the decoder creates s
Figure FDA0002556970870000028
Subnode and redirect s to it
Figure FDA0002556970870000029
A child node of (1); otherwise, the decoder calls the prune _ path function to prune the path ending at the s node and terminate the pass; this problem is compounded if u falls within the overlap interval, so the branch function is defined to describe the behavior of the decoder at the cross-point; if a transfer is not terminated to a leaf node, it is called a complete transfer, which means that the complete path ending at the leaf node must be the best full path so far, and therefore the hamming distance d between the minimum full path and the side information must be updatedmin；
4) Decoder behavior at the fork node: if s is a cross node, unless this path is terminated, at least one s sub-path is feasible, i.e., if the left sub-path of s is infeasible, its right sub-path must be feasible, and vice versa; if all sub-paths of s are feasible, the corresponding sub-nodes are better, namely the sub-paths are selected to continue the path for better overall index, and unselected branches are stored in the spaths array;
5) node compression list of pause path: after each full path, the decoder updates d with the hamming distance between the full path ending with bst and the side informationmin(ii) a Then use the new dminThe decoder compresses the spaths array by removing the node pointers to the end nodes of the unconditional pause path: if the Hamming distance between the path and the side information is equal to or greater than dminThen the path will be pruned and it points to itThe node pointer of the end node will be deleted from the spaths array;
6) online memory release: compressing the list and partially releasing memory allocated to the garbage path by function call pruning the path function by iteratively deleting the end node of the unconditional path backwards until the end node is shared with other paths;
7) selecting the best pause path: after calling the compression list function, all elements in the spaths point to the end node of the possible pause path; then the decoder calls the wave _ path function and selects the best pause path from the pause list according to the total path metric; once the optimal pause path is determined, a new traversal will be started from its end node, while the node pointer to its end node will be removed from the spaths;
8) termination conditions were as follows: the termination condition of the depth-first decoder depends on the actual constraints; if the decoder is not complexity constrained, the termination condition may be the number of pause paths that it is desired to store: if nsp is 0, i.e. spaths is empty, decoding is stopped, which means that the DAC tree has been completely searched; if the decoder is constrained by complexity, the number of nodes created can be used as a termination condition: if the number of created nodes exceeds a threshold, decoding is stopped.
2. The method of claim 1, wherein in step 5), if the number of possible pause paths exceeds the spaths size, a memory overflow occurs; in this case, the decoder orders the possible pause paths according to their overall metric and discards some bad ones, but this carries the risk of incorrect pruning of the correct paths.
3. The depth-first based distributed arithmetic code decoding method of claim 1, wherein in step 6), the path is known
Figure FDA0002556970870000031
After it is not possible to do so,the prune path function iteratively deletes nodes in the dashed ellipse back and eventually stops at the and path
Figure FDA0002556970870000032
And sharing the nodes.
CN201710419222.0A 2017-06-06 2017-06-06 Depth-first-based distributed arithmetic code decoding method Expired - Fee Related CN107294656B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN201710419222.0A CN107294656B (en) 2017-06-06 2017-06-06 Depth-first-based distributed arithmetic code decoding method

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN201710419222.0A CN107294656B (en) 2017-06-06 2017-06-06 Depth-first-based distributed arithmetic code decoding method

Publications (2)

Publication Number Publication Date
CN107294656A CN107294656A (en) 2017-10-24
CN107294656B true CN107294656B (en) 2021-02-02

Family

ID=60094763

Family Applications (1)

Application Number Title Priority Date Filing Date
CN201710419222.0A Expired - Fee Related CN107294656B (en) 2017-06-06 2017-06-06 Depth-first-based distributed arithmetic code decoding method

Country Status (1)

Country Link
CN (1) CN107294656B (en)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN110380737B (en) * 2019-07-12 2020-10-02 北京邮电大学 Method and device for distance spectrum analysis of polarization code

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102831241A (en) * 2012-09-11 2012-12-19 山东理工大学 Dynamic index multi-target self-adaptive construction method for product reverse engineering data
CN103326731A (en) * 2013-04-16 2013-09-25 西北农林科技大学 Hidden Markov related source coding method based on distributed arithmetic coding
CN103501210A (en) * 2013-09-30 2014-01-08 复旦大学 High-performance multistandard FEC (Forward Error Correction) decoder

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20100031130A1 (en) * 2008-08-04 2010-02-04 Legend Silicon Corp. Forward error correction (fec) and variable length code (vlc) joint decoding

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102831241A (en) * 2012-09-11 2012-12-19 山东理工大学 Dynamic index multi-target self-adaptive construction method for product reverse engineering data
CN103326731A (en) * 2013-04-16 2013-09-25 西北农林科技大学 Hidden Markov related source coding method based on distributed arithmetic coding
CN103501210A (en) * 2013-09-30 2014-01-08 复旦大学 High-performance multistandard FEC (Forward Error Correction) decoder

Also Published As

Publication number Publication date
CN107294656A (en) 2017-10-24

Similar Documents

Publication Publication Date Title
US10110345B2 (en) Path sort techniques in a polar code successive cancellation list decoder
CN101635611B (en) Channel decoding method and channel decoding device
CN103997346B (en) Data matching method and device based on assembly line
CN101997553B (en) Method and device for decoding convolution code
CN109889205B (en) Coding method and system, decoding method and system, coding and decoding method and system
CN102543149A (en) Systems and methods for performing efficient decoding using a hybrid decoder
CN110874425B (en) Hardware ordering accelerators sharing a first level processor cache
CN110661533B (en) Method for optimizing decoding performance of decoder for storing polarization code
CN104143991B (en) The interpretation method and device of polarity Polar codes
CN107294656B (en) Depth-first-based distributed arithmetic code decoding method
TWI306335B (en) System and method for blind transport format detection with cyclic redundancy check
US7404139B2 (en) Decoder with M-AT-A-Time Traceback
CN103634015B (en) The maximum-likelihood decoding algorithm of tail biting code
US9455742B2 (en) Compression ratio for a compression engine
CN110798231B (en) Decoding method, device and storage medium of tail biting convolutional code
CN105610550B (en) A kind of Viterbi interpretation method for power line carrier communication
JP4803057B2 (en) Error correction code decoding apparatus
CN115563116A (en) Database table scanning method, device and equipment
US9703920B2 (en) Intra-run design decision process for circuit synthesis
Mohan et al. Computationally optimal metric-first code tree search algorithms
CN111404558B (en) Polar code decoding method, decoder and computer storage medium
Farruggia et al. Bicriteria data compression
CN106452461A (en) Method for realizing viterbi decoding through vector processor
CN112685404A (en) Encoding method applied to key tree, decoding method applied to key tree and electronic device
CN107872232B (en) Novel convolutional code maximum likelihood decoding algorithm of closing behind

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant
CF01 Termination of patent right due to non-payment of annual fee

Granted publication date: 20210202

Termination date: 20210606

CF01 Termination of patent right due to non-payment of annual fee