TABLA DE CONTENIDO

1. UNA MIRADA HISTORICA AL CODIGO BCH..................................................................2

1.1 BCH (Bose–Chaudhuri–Hocquenghem)........................................................................2
2. CODIGOS BCH.......................................................................................................................3
2.1 DEFINICIÓN..........................................................................................................................8
3. CODIFICACION Y ALGORITMO PARA DECODIFICACION DE BCH.............................9
3.1 ALGORITMO DE DECODIFICACIÓN.............................................................................11
4. CODIFICADOR BCH...............................................................................................................13
5. UNA MIRADA HISTORICA AL CODIGO LDPC..............................................................14
6. CODIGOS LDPC...................................................................................................................15
6.1 DEFINICIÓN...................................................................................................................16
7. BIBLIOGRAFIA........................................................................................................................22
 1. UNA MIRADA HISTORICA AL CODIGO BCH

1.1 BCH (Bose–Chaudhuri–Hocquenghem)

El nombre BCH proviene de sus inventores, en 1959 por el matemático

francés Alexis Hocquenghem, e independientemente en 1960 por Raj
Bose y DK Ray-Chaudhuri, los códigos BCH en la teoría de la codificación
conforman unos ciclos de código para la corrección de errores, los cuales se
construyen utilizando campos finitos. Esta clase de códigos es una extraordinaria
generalización de los códigos de Hamming para la corrección de varios errores.
Una de las característica de estos códigos es que durante el diseño del código hay
un control preciso sobre el número de errores de símbolos corregibles por el
código, en particular es posible diseñar códigos BCH binarios para corregir errores
de bit múltiples. La forma de decodificar los códigos BCH no es tan compleja, ya
que solo hay que utilizar el método algebraico conocido como síndrome de
decodificación, simplificando el diseño del decodificador usando hardware de baja
potencia.1

__________________________________________
1 http://en.wikipedia.org/wiki/BCH_code

2. CODIGOS BCH

Los códigos de Bose–Chaudhuri–Hocquenghem (BCH) son una generalización de

los códigos de Haming que permiten la corrección de errores múltiples. Ellos son
una clase potente de códigos cíclicos que provee una gran selección de bloques
largos, razones de código, tamaños alfabéticos, y correcciones de errores
compatibles. La figura 1 lista algunos generadores de códigos g(x) comúnmente
usados para la construcción de códigos BCH [8], para varios valores de n, k, y t,
sobre un bloque de longitud 255. Los coeficientes de g(x) son presentados como
números octales organizados de manera tal que cuando ellos son convertidos a
dígitos binarios el dígito del extremo derecho corresponde al coeficiente de grado
cero de g(x). Desde la figura 1, uno puede verificar fácilmente una propiedad del
código cíclico – el polinomio generador es de grado n – k. Los códigos BCH son
importantes dado a la longitudes de bloques de unos pocos centenares, los
códigos BCH mejoran a los otros bloques de códigos con la misma longitud de
bloque y razón de código. Los códigos BCH más comúnmente usados ocupan un
alfabeto binario y un bloque de codeword de longitud de n = 2 m – 1, donde m = 3,
4,....
El título de la figura 1 indica que los generadores mostrados son para aquellos
códigos BCH conocidos como códigos primitivos. El término “primitivo” es un
concepto numérico teórico que requiere un desarrollo algebraico [7, 10–11]. En las
Figuras 2 y 3 están graficadas las curvas de rendimiento de error de dos códigos
BCH (127, 64) y (127, 36), para ilustrar la comparación de los rendimientos.
Asumiendo una decodificación de decisión dura, el P B contra la probabilidad de
error del canal p es mostrado en la Figura 2. El P B contra Eb/N0 para una coherente
demodulación BPSK sobre un canal Gaussiano se muestra en la Figura 3. Las
curvas en la Figura 3 aparecen a partir de nuestras expectativas. Cada una de
ellas tiene el mismo tamaño de bloque, sin embargo el código más redundante
(127, 36) no exhibe mucha ganancia de codificación como el código menos
redundante (127, 64). Él tiene que mostrar que un ancho máximo relativo de
ganancia de codificación contra la razón de código para aproximadamente n
ocurrencias fijas entre razones de codificación de 1/3 y ¾ para códigos BCH [12].
El rendimiento sobre un canal Gaussiano decae sustancialmente a muy altas o
muy bajas velocidades [11].
La Figura 4 representa el cálculo del rendimiento de los códigos BCH [13] usando
una coherente demodulación BPSK con ambas decodificaciones de decisión–
flexible y dura. La decodificación de decisión flexible no es usualmente utilizada
con bloques de códigos a causa de su complejidad. Sin embargo, cuando quiera
que esto sea implementado, ella ofrece una ganancia de codificación de
aproximadamente 2 dB sobre una decodificación de decisión dura. Para una
determinada razón de código, la probabilidad de error decodificada es conocida
para mejorar por medio del incremento de la longitud del bloque n [4].

FIGURA 1. Tabla generadora de códigos BCH

FUENTE:” Digital Communications, Fundamentals and Applications”. SKLAR, BERNARD.

FIGURA 2. Curvas de Rendimiento de Error

 FIGURA 3. Curvas de Rendimiento de Error

FUENTE:” Digital Communications, Fundamentals and Applications”. SKLAR, BERNARD.

 FIGURA 4. PB contra Eb/N0

FUENTE:” Digital Communications, Fundamentals and Applications”. SKLAR, BERNARD.

Así, para una determinada razón de código, ésta está creciendo para considerar la
longitud del bloque que será requerida por el funcionamiento de la decodificación
de decisión dura para ser comparada con el funcionamiento de la decodificación
de decisión flexible. En la Figura 4. Los códigos BCH muestran que todos tienen
razones de código de aproximadamente ½. De la figura [4] surge que para una
razón de código fija, la decodificación de decisión dura del código BCH de 8 veces
n de longitud o mayor tiene un mejor rendimiento (para un P B de aproximadamente
10-6 o menor) que aquel de una decodificación de decisión flexible del código BCH
de longitud n. 59
Una subclase especial de los códigos BCH (el descubrimiento de los que
preceden los códigos BCH) es el particularmente útil conjunto no binario llamado
códigos de Reed–Solomon. [1]

En estos códigos cíclicos, se busca que tenga una longitud y distancia designada.

2.1 DEFINICIÓN.
Sea Fqr el cuerpo de escisión de Xn 1 que contiene a Fqr y sea r una
raíz n-esima primitiva de la unidad.
Sean Cambiando r, por , tenemos cinco
parámetros,
Llamamos código BCH de longitud n y distancia designada sobre Fqr y lo
denotamos Bq (el parámetro que sale del paréntesis) al Código
Cíclico generado por

1. En el caso b = 1, el código se llama BCH en sentido restringido (narrow

sense) y se omite el ultimo parámetro, es decir, se escribe
2. Si es un elemento primitivo de Fqr, diremos entonces que el código es BCH
primitivo. Nótese que esto ocurre si y solo si n = qr 1.
Trivialmente, todo código de Haming es BCH (primitivo y restringido), con
parámetro
1

_____________________________________________
1. http://www.um.es/docencia/jsimon/depmat/2011-2012/Codigos/ApuntesCodigosMasterCompleto.pdf
 3. CODIFICACION Y ALGORITMO PARA DECODIFICACION DE BCH

Los códigos Bose-Chaudhuri-Hocquenghem son una clase importante de códigos

porque la decodificación es simple y son baratos.

Para cualquier entero r y t tales que t ¿ 2r-1-1 existe un código BCH de longitud n
= 2r-1 que corrige t errores y tiene dimensión k ¿ n-r*t (la dimensión lineal del
subespacio c de kn).

Un código BCH corrector de dos errores de longitud lineal cíclico que es generado
por:
3
G(x) = mβ ( x)∗mβ ( x)

Donde  es el elemento primitivo de GF (2r) y 4 ¿ r. Como n = 2r-1 y g(x) divide a

1+xn, entonces g(x) es el polinomio generador.

Por ejemplo, sea  el elemento primitivo de GF (24) construido con p(x)= 1 +x +x4,
entonces:

m1(x) = 1 +x +x4, m3(x) = 1 +x +x2 +x3 +x4

Como ya se vio:

G(x) = m1(x)*m3(x)
G(x) = 1 +x4 +x6 +x7 +x8 es el polinomio generador.

Ahora para 2 errores y g(x) = m1(x)*m3(x) HT es de la forma:

β0 β0

T
H =
[ ]
.
.
.
β1

r
β2 −2
.
.
.
β
β3

r
3 (2 −2 )

Para este ejemplo HT es de 15 x 8.

 1 1 1 0 0 0 1 0 0 0
3

[] [ ]
β β 0 1 0 0 0 0 0 1
β2 β6 0 0 1 0 0 0 1 1
3 9
β β 0 0 0 1 0 1 0 1
β4 β 12 1 1 0 0 1 1 1 1
β5 1 0 1 1 0 1 0 0 0
β6 β3 0 0 1 1 0 0 0 1
β7 β6 1 1 0 1 0 0 1 1
β8 β9 1 0 1 0 0 1 0 1
β9 β 12 0 1 0 1 1 1 1 1
β10 1 1 1 1 0 1 0 0 0
β 11 β3 0 1 1 1 0 0 0 1
β12 β6 1 1 1 1 0 0 1 1
β13 β9 1 0 1 1 0 1 0 1
14 12
β β 1 0 0 1 1 1 1 1
HT =

Supongamos que se recibe la palabra w w(x) el síndrome de w es:

wHT = [w () + w (3)] = [s1, s3]

Donde s1, s3 son de longitud r.

Si no hay errores en la transmisión, el síndrome es wH T = 0, así que s1 = s3 = 0. Si

ocurre sólo un error, este será e(x) = xi y

wHT = eHT = [e (), e (3)] = [i, 3i] = [s1, s3]

3
Donde s 1 =s 3
Si ocurren dos errores en la transmisión, en las posiciones i, j donde ij, entonces:

e(x) = xi + x j y
wHT = eHT = [e() + e(3)] = [s1 , s3] = [i +j ,3i + 3j]

Del sistema de ecuaciones que se forma:

i +j = s1
3i + 3j = s3

y se obtiene i ,j , como las raíces de la ecuación cuadrática:

x2 + (i +j)x + i+j = 0

Y de las raíces de:

 s3
2
x2 + s1x + ( s 1 + s1 ) = 0

Por ejemplo, sea w la palabra recibida con síndrome w() = s1 = 0111 y w(3)= s3 =
1010.
De la tabla s1 11 y s3 8 , entonces:

s3 β8
+ s 21= + β 22=β 8 β−11 + β 7= β12 + β 7 2
s1 β 11 = 1111+1101=0010=β

Se forma el polinomio x2 + 11x + 2 = 0, las raíces son 4 y 13 (estas se obtienen

probando 6 , 1 , 2,...).

Errores en las posiciones 4 y 13, e(x) = x4 + x13, y el patrón de error es 0000 1 0000
0000 10

3.1 ALGORITMO DE DECODIFICACIÓN.

Para código BCH y 2 errores con polinomio generador m 1(x)*m3(x):

1. Calcular wH = [s1 , s3] = [w() + w(3)]

2. Si s1= s3= 0, concluir que no hay errores. Se decodifica c=w.
3. Si s1= 0 y s1 0 se pide retransmisión.
3
4. Si s 1 = s3 hay un error en la posición i, donde s1= i.
s3
2
5. Formar la ecuación cuadrática x 2 + s1x + ( s 1 + s 1 ) = 0 y obtener las
raíces.
6. Si la ecuación tiene dos raíces distintas i y j , los errores están en las
posiciones i y j.
7. Si la ecuación no tiene raíces distintas en GF (2 r), se concluye que hay al
menos tres errores.
Ejemplo.

Con el ejemplo la matriz HT y el polinomio generador mencionado, obtener el

patrón de errores. Asumir que w es recibida y el síndrome wH T= 01111010  [11 ,
8]

Solución.
1) Ya
2) No
3) No
 3 11 3 33 3 8
4) s 1 =( β ) =β =β + β =s 3 , no
2 11 2 4 13
5) x +β x+β =0 , del ejemplo anterior, raíces β y β
6) Los errores en las posiciones 4 y 13, el patrón de errores es:
u = 000010000000010
Ejemplo.
Asumir que wHT= [w() + w(3)]= [3 , 9], obtener el patrón de errores.
Solución.
1) ya
2) No
3) No
3 3 3 9
4) s 1 =( β ) =β =s 3 Un error en la posición 3,el patrón de errores es:
u = 000100000000000

Ejemplo.
Asumir que w= 1101 1110 1011 000 se recibe. Obtener el vector transmitido.

Solución.
1) wHT= 0111 0110 [11 , 5] = [s1 , s3]
2) No
3) No
3 11 3 33 3 5
4) s 1 =( β ) =β =β + s 3 =β , no
s3 2 β 5
+ s 1= 11 +( β 11 )2 =β 9 + β7 0
5) s 1 β 0101 + 1101 = 1000 β , se tiene
2 11 0
x +β x+β =0

Se prueban

β 0 : β 0 +β 11 β 0 +β 0 =. ..≠0
β 1 : β2 +β 11 β 1 + β0 =. ..≠0
.
.
.
β 7 : β 14+ β11 β 7 + β 0=. . .=0
7 7 j 15 j 8
Una raíz es β . Como β β =1= β ⇒ β =β es la otra raíz.
6) Errores en la posiciones 7 y 8. Así:
u = 0000 0001 1000 000
En conclusión:
v = w+u = 1101 1111 0011 000
Es la palabra enviada. 1
____________________________________
1. www.fi-b.unam.mx/Profesores/AbelHerrera/.../descargas/capitulo7.doc

4. CODIFICADOR BCH

Un codificador BCH incluye tmax registros de desplazamiento con realimentación

lineal ('LFSRs'). En un estado de entrada de datos, cada LFSR forma un resto de
una secuencia de entrada correspondiente de bits representados como un
polinomio de entrada en una variable x con una respectiva m polinomio, en la
variable x, con pre-multiplicación de la respectiva m, polinomio por el factor de
x.sup.m, cada uno de los polinomios de tmax que tienen un grado m. El estado de
la entrada de datos se mantiene mientras que el bloque de datos de entrada es
velocidad de reloj en el codificador BCH. El m, polinomios (i = 1... 2t.sub.max-1)
son los polinomios irreducibles de un polinomio generador del codificador BCH. En
un estado de generación de paridad, cada LFSR está configurado para formar un
producto del respectivo polinomio resto con la m respectiva del polinomio. Se
mantiene el estado de generación de paridad, mientras que la secuencia de bits
de paridad se registró hacia fuera del codificador BCH. El codificador BCH incluye
además multiplexores tmax, en el que una salida de cada multiplexor está
acoplado a una entrada respectiva LFSR. En el estado de entrada de datos, una
primera entrada del primer multiplexor está acoplado a un bloque de datos de
entrada al codificador BCH, y una primera entrada de cada multiplexor sucesiva
está acoplado a una salida del LFSR anterior. En el estado de generación de
paridad, una segunda entrada del último multiplexor se pone a cero y una segunda
entrada de cada multiplexor anterior está acoplado a una salida de un LFSR tener
éxito. El resto representa una secuencia de bits de paridad para el bloque de datos
de entrada al codificador BCH. El codificador BCH está configurado para corregir
hasta un máximo seleccionable de errores en el bloque de datos de entrada, la
máxima seleccionable que no exceda de tmax.

El codificador BCH además, incluye un número excesivo de LFSR que están

desactivados selectivamente por una señal de entrada. En una forma de
realización, el exceso de número de LFSR incluye LFSR más allá del número de
LFSR necesarias para llevar a cabo un proceso de codificación para corregir hasta
el número máximo seleccionable de errores en el bloque de datos de entrada.
También incluye un proceso de exponenciación polinomio acoplado a una salida
LFSR, en el que el codificador de BCH en un estado de generación de síndrome
realiza la división polinómica sin pre-multiplicación por el factor de x.sup.m, y en el
que el proceso de exponenciación en el estado de generación de síndrome
produce un síndrome parcial del polinomio resto resultante del bloque de datos de
entrada. En una forma de realización, el proceso de exponenciación polinomio
plantea la respectiva salida de LFSR polinomio a una potencia relacionada con un
número de la respectiva LFSR en el estado de generación de síndrome. El estado
de generación de síndrome se mantiene durante un proceso de decodificación. 1
______________________________________________________
Texto citado de a biblioteca virtual del SENA
1.
 5. UNA MIRADA HISTORICA AL CODIGO LDPC

Los códigos Low Density Parity Check fueron creados por Robert G. Gallager en
MIT (Massachusetts Institute of Technology) en el 1960. Estos fueron olvidados
hasta aproximadamente los 90's. En su tesis de doctorado de 1961 (publicada en
1963), Gallager inventó los códigos LDPC y la decodificación iterativa. Pero debido
a limitaciones existentes en los equipos de la época y a ciertas confusiones los
sistemas de codificación iterativos fueron olvidados durante décadas. En 1993, se
inventó otro sistema de codificación iterativa: los códigos Turbo. A la luz de este
descubrimiento, los códigos LDPC fueron redescubiertos por MacKay y Neal en
1995. Luego de ese redescubrimiento, han surgido y siguen surgiendo una
cantidad importante de trabajos relacionados con el tema. Se relacionan con los
Turbo Codes, pero su estructura algebraica es más conocida.

El gran interés por los sistemas de codificación basados en códigos LDPC se debe
a que permiten comunicar con eficiencia muy cercana al límite establecido por
Shannon, con confiabilidad arbitrariamente grande y con muy baja complejidad
para una gran variedad de medios de comunicación 1.

Algunas de las aplicaciones posibles de los códigos LDPC son:

- recuperación de paquetes perdidos en la distribución de datos masivos a

varios clientes en forma simultánea a través de Internet.

- almacenamiento en medios magnéticos.

- almacenamiento distribuido de información.

- corrección de errores en telefonía común o inalámbrica y en módems.

__________________________________________________________________
1 http://en.wikipedia.org/wiki/Low-density_parity-check_code
 6. CODIGOS LDPC

Los códigos LDPC son códigos lineales cuya propiedad esencial es la de tener por
lo menos una matriz de paridad de baja densidad, es decir con “pocos” elementos
distintos de cero. Formalmente, decimos que una secuencia (en el largo n ) de
códigos es LDPC si cada código tiene por lo menos una matriz de paridad en la
cual la cantidad de elementos distintos de cero es O(n).

Es debido a este tipo de estructura que los algoritmos de codificación y de

decodificación tienen complejidad lineal en el largo del código. Si esos mismos
algoritmos se usaran con matrices densas, es decir, matrices que tienen una
cantidad O(n2) de elementos mayores que cero, entonces los algoritmos tendrían
complejidad de orden cuadrático en el largo del código.

Si consideramos la caracterización de los códigos lineales mediante el sistema de

ecuaciones HxT = 0 , vemos que los elementos distintos de cero de cada fila de la
matriz de paridad determinan cuales posiciones de las palabras de código
pertenecen a cada ecuación. Por lo tanto, si definimos el conjunto V de los índices
de las palabras de código y el conjunto C de los índices de las ecuaciones
definidas por H , tenemos una relación entre elementos de C y elementos de V .
Esta relación se puede representar mediante un grafo bipartito y la matriz de
paridad se puede ver como una matriz de adyacencia del grafo. Este tipo de
representación de los códigos lineales se llama grafo de Tanner1.

Por ejemplo, consideremos la matriz de paridad del código de Hamming sigui ente:

0 0 01 1 11
(
A= 0 1 1 0 0 1 1
1 0 10 1 01 )
El grafo bipartito correspondiente se muestra en la Figura,

__________________________________________________________________
1http://www.rle.mit.edu/rgallager/documents/ldpc.pdf
Los elementos de V se denominan variables o nodos izquierdos y los elementos
de C se denominan checks o nodos derechos.

6.1 DEFINICIÓN.

Siendo H la matriz de chequeo de paridad y G la matriz generadora, si se definen

wr y wc como el número de unos por fila y por columna respectivamente que posee
la matriz H, ésta se considera de baja densidad si wc<<k y wr<<n.

De acuerdo a esto, la matriz de paridad ha de ser grande para considerarse de

baja densidad.

Asimismo, a partir de estos parámetros se pueden clasificar los LDPC como:

1. LDPC regulares: si las filas y columnas de H tienen un peso uniforme, es decir,

si wc y wr = wc∙(n/k) son constantes para cada fila y columna (en el ejemplo, w c = 2
y wr = 4); n y k son los valores que definen el código bloque ( n, k ).

2. LDPC irregulares: si las filas y columnas de G no tienen un peso uniforme, es

decir, si wr y wc no son constantes.

Una matriz generadora de un código con control de paridad matriz H se puede

encontrar mediante la realización de Gauss-Jordan eliminación de H para
obtenerlo en forma

H= [ A , I n−k ]

donde A es una matriz binaria (n-k)×k e I n−k es el tamaño de la matriz identidad.

La matriz generadora es entonces,

G=[ I k , A T ]

Para detallar el proceso se usa el siguiente ejemplo:

Se desea codificar desea codificar el código LDPC de longitud 10.
 1 1 0 1 1 0 0 1 0 0
0
H= 0
1
0
( 1
0
1
0
1
0
0
1
0
1
0
0
1
0
0
0
1
0
1
1
1
0
1
0
0
1
0
1
0
1
1
0
0
1
0
1
)
En primer lugar, se escribe a H en forma escalonada (es decir, para que en
cualquiera de las dos filas sucesivas que no consistan enteramente de ceros, el
principal 1 en la fila inferior se produce más a la derecha que el líder de 1 en la fila
superior).

La matriz H se pone en esta forma mediante la aplicación de las operaciones

elementales de fila en GF (2), que son; intercambiando dos filas o la adición de
una fila a otra en módulo 2. Desde el álgebra lineal mediante el uso de
operaciones de fila única elementales de la matriz de control de paridad
modificado tendrá la misma palabra en clave para establecer que el original,
(como el nuevo sistema de ecuaciones lineales tendrá un conjunto de soluciones
sin cambios).

La primera y segunda columna de H ya tienen unos en la diagonal y las entradas

en estas columnas debajo de la diagonal se eliminan mediante la sustitución de la
cuarta fila con la suma módulo 2 de la primera y cuarta fila. La tercera columna de
H no tiene uno en la diagonal, pero esto se puede conseguir mediante el canje de
la tercera y quinta fila.

Por último, en sustitución de la quinta fila con la suma en módulo dos de las filas 5
y 4 de H en forma escalonada:

1 1 0 1 1 0 0 1 0 0

(
0
Hr= 0
0
0
1
0
0
0
1
1
0
0
0
0
1
0
1
0
1
1
1
1
1
1
1
0
1
1
0
1
1
0
0
0
1
0
0
1
0
1
)
A continuación, la matriz de control de paridad se pone en forma reducida
escalonada (es decir, de manera que cualquier columna que contenga un líder uno
tiene ceros en todas partes). La columna 1 ya está correcta y la entrada en la
columna de la 2 por encima de la diagonal se elimina mediante la sustitución de la
fila 1 con la suma módulo 2 de la primera y segunda fila. Del mismo modo la
entrada en la columna 3 encima de la diagonal se elimina mediante la sustitución
de la fila 2 con la suma de módulo 2 de las filas 2 y 3. Para borrar la columna 4 de
la fila 1 es reemplazar con la suma módulo 2 de la primera y cuarta fila. Por último,
para despejar la columna 5 implica añadir la fila 5 a la 1, 2 y filas de 4 da Hrr en
forma escalonada reducida:

1 0 0 0 0 0 1 1 1 0
0
Hr= 0
0
0
( 1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
1
1
0
1
0
0
0
1
1
1
1
0
0
0
1
0
0
1
1
1
)
Por último, el uso de permutaciones de columnas que se colocan en la matriz de
control de paridad en la forma estándar (donde las últimas m columnas de apoyo
invertido son las m columnas de Hrr que contienen los que llevan la delantera):

0 1 1 1 0 1 0 0 0 0

( 1
H std = 1
0
1
0
0
0
1
1
1
1
0
0
0
1
0
0
1
1
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
)
En este paso final las permutaciones de columnas se han utilizado por lo que las
palabras de código de apoyo invertido se han permutado versiones de las
palabras de código correspondiente a H. Una solución es hacer un seguimiento de
la permutación de columna utilizada para crear apoyo invertido, que en este caso
es,

Ԥ=[ 6 7 8 9 10 1 2 3 4 5 ]

y aplicar la permutación inversa a cada palabra de código apoyo invertido antes de

ser transmitida.

Alternativamente, si el canal es sin memoria, y por lo que el orden de los bits de

palabra de código no es importante, una opción mucho más fácil es aplicar al
original H para dar una matriz de control de paridad,

1 1 0 1 1 0 0 1 0 0

(
0
H '= 0
1
0
1
0
1
0
1
0
0
1
0
1
0
0
1
0
0
0
1
0
1
1
1
0
1
0
0
1
0
1
0
1
1
0
0
1
0
1
)
con las mismas propiedades como H pero que comparte el mismo orden de los
bits de palabra de código como apoyo invertido.

Todo este procesamiento se puede hacer fuera de línea y sólo las matrices G y H'
proporcionan al codificador y decodificador respectivamente. Sin embargo, el
inconveniente de este enfoque es que, a diferencia de H, la matriz G lo más
probable es que no sea escasa y por lo que la multiplicación de matrices,

c=uG

en el codificador tendrá complejidad en el orden de las operaciones n2. Como n es

grande para los códigos de LDPC, de miles a cientos de miles de bits, el
codificador puede llegar a ser prohibitivamente complejo. Las matrices de control
de paridad
estructurados pueden utilizarse para reducir de manera significativa esta
complejidad de la implementación, sin embargo, por arbitraria de control, un buen
enfoque de paridad matrices es evitar la construcción de G en todo y en lugar de
codificar utilizando de nuevo la sustitución con H.

Ejemplo usando matlab:

% Construct a companion LDPC decoder object

dec = fec.ldpcdec;
dec.DecisionType = 'Hard decision';
dec.OutputFormat = 'Information part';
dec.NumIterations = 50;
% Stop if all parity-checks are satisfied
dec.DoParityChecks = 'Yes';

% Generate and encode a random binary message

msg = randint(1,enc.NumInfoBits,2);
codeword = encode(enc,msg);

% Construct a BPSK modulator object

modObj = modem.pskmod('M',2,'InputType','Bit');

% Modulate the signal (map bit 0 to 1 + 0i, bit 1 to -1 + 0i)

modulatedsig = modulate(modObj, codeword);

% Noise parameters
SNRdB = 1;
sigma = sqrt(10^(-SNRdB/10));

% Transmit signal through AWGN channel

receivedsig = awgn(modulatedsig, SNRdB, 0); % Signal power = 0 dBW

% Visualize received signal

scatterplot(receivedsig)

% Construct a BPSK demodulator object to compute

% log-likelihood ratios
demodObj = modem.pskdemod(modObj,'DecisionType','LLR', ...
'NoiseVariance',sigma^2);

% Compute log-likelihood ratios (AWGN channel)

llr = demodulate(demodObj, receivedsig);

% Decode received signal

decodedmsg = decode(dec, llr);

% Actual number of iterations executed

disp(['Number of iterations executed = ' ...
num2str(dec.ActualNumIterations)]);
% Number of parity-checks violated
disp(['Number of parity-checks violated = ' ...
num2str(sum(dec.FinalParityChecks))]);
% Compare with original message
disp(['Number of bits incorrectly decoded = ' ...
num2str(nnz(decodedmsg-msg))]);
 7. BIBLIOGRAFIA

[1] SKLAR, BERNARD.” Digital Communications, Fundamentals and Applications”.

Los Ángeles: Prentice Hall; (2001) páginas 370-374.
TRABAJO DE COMUNICACIONES III
CODIGOS BCH
CODIGOS LDPC
 GUSTAVO ANDRES BECERRA
JORGE MORALES SEPULVEDA
ADRIAN COSTA OSPINO
SERGIO RUIZ PONZON

ING HECTOR MARIN

UNIVERSIDAD POPULAR DEL CESAR

FACULTAD DE INGENIERIAS
VALLEDUPAR
2014