Método de Hamming

Ir a la navegaciónIr a la búsqueda
El método Hamming es un tipo de codificación por bloques.
En el proceso de comunicación y envió de mensajes con el uso de las actuales
tecnologías, existen diferentes errores al intercambiar información. En otros
tiempos, las cartas podían llegar con errores ortográficos, mojadas, retrasadas
o simplemente en ocasiones no llegaban a su destino. En la comunicación
mediante computadoras sucede algo parecido, es decir, la tecnología no se
exonera de los errores que puedan aparecer al enviar información.

Índice

 1Código de Hamming
 2Errores
 3Distancia de Hamming
 4Tipo de codificación
 5Eficiencia
 6Deficiencia
 7Método de Hamming para una Matriz [12][8] en Java
 8Referencias
 9Véase también
 10Enlaces externos

Código de Hamming[editar]
Un código Hamming es un código de bloque capaz de identificar y corregir
cualquier error de bit simple que ocurra dentro de él. Se identifica, como en el
teorema de Hamming, por los números K y Kc, según código de Hamming se
denomina por . Este código, como el de bloques, emplea aritmética módulo 2.
El código Hamming debe su nombre a su desarrollador y descubridor Richard
Hamming.

Errores[editar]
Primero se debe conocer que es un error, que no es más que un dato que tiene
m bits y se le agregan r bits de redundancia o de chequeo, por tanto, los bits a
transmitir serán n = m + r. Existen métodos que detectan errores y otros que
corrigen errores o ambos a la vez. Uno de esos métodos es el método de
Hamming, el cual corrige y detecta errores de grado x. Para la detección de
errores, considere un sistema de transmisión que al codificar, genera un
alfabeto con un número N de secuencias , n = 1 · · · N, y una de esas
secuencias se transmite sobre el canal. Debido a los errores, se recibe . El
decodificador entonces determina que la secuencia enviada es aquella del
alfabeto generado, cuya distancia Hamming entre y  sea mínima.

Distancia de Hamming[editar]
Artículo principal: Distancia de Hamming
La distancia de Hamming es el número de bits en que difieren dos palabras
del código. Si dos palabras están separadas una distancia d, se requerirán de
errores simples para convertir una en la otra. La mínima es la distancia del
código. En general hay 2m mensajes válidos pero no todos los 2n lo son. La
idea de similitud es más consistente debido a la definición de la distancia
Hamming.
Sean  y  dos secuencias binarias de la misma longitud i, j = 1,..., K, la distancia
Hamming entre ellas es el número de símbolos en que difiere. Siendo W  el
peso de Hamming de una secuencia y  el número de unos de la secuencia, la
distancia Hamming dij = d está dada por:

dij = W

donde ⊕ será la suma modular entre 2 secuencias de longitud iguales, no

pueden ser de longitudes distintas. Por ejemplo un ⊕ entre:

= 000

= 111

d = W (000 ⊕ 111) = 3

Tipo de codificación[editar]
El método Hamming es un tipo de codificación por bloques, que trabaja de la
siguiente manera: cada vez que, y solamente cuando llegan al codificador k
símbolos (mensaje), este envía al siguiente bloque, l símbolos (palabra código),
dependientes únicamente de los k recibidos (una palabra código asociada a
cada mensaje), con l > k. El ruido del canal se combate gracias a la
redundancia (n − k) de la información. Codificadores de se suelen utilizar como
códigos externos, más cercanos a la fuente, cuando se utilizan en combinación
con los continuos. Tasa del codificador: R = k/l.

Eficiencia[editar]
Para diseñar un buen código, se trata de asegurar que la distancia Hamming
entre posibles códigos  sea más larga que la distancia Hamming proveniente
del error. Por lo que el decodificar puede describirse como: “Elegir la palabra de
código con la mínima distancia Hamming de la palabra recibida”. Un código con
todas las palabras distintas debe tener al menos una distancia de Hamming
mínima. Las prestaciones de un código continuo no sólo dependen de un buen
algoritmo de codificación, también dependen de las propiedades de distancia
del código.
La importancia de este parámetro en un código reside en que la probabilidad
de error de decodificación es menor cuanto mayor es la distancia Hamming.
Esto es porque, cuanto mayor sea la distancia, más variaciones deber producir
́el canal en la secuencia transmitida, para que en la decodificación se produzca
un error al confundir la secuencia de entrada que generará la secuencia
codificada.

Deficiencia[editar]
Los Código Hamming tienen la misma dificultad que los códigos de bloque,
pues sólo ofrecen protección contra errores de bit simple, es decir errores de
grado 1, y ofrecen una pequeña protección contra errores dispersos. Además el
decodificador, denominado de decisión remanente, recibe la señal cuantificada
del demodulador sin importar cuan grande fue el error de la señal analógica
recibida.

Método de Hamming para una Matriz [12][8] en

Java[editar]
Se parte de un código de n dígitos de distancia mínima uno 1. Estos n dígitos
son conocidos dentro del código de Hamming como "dígitos de datos". A
continuación se le añaden p (cp-1,..., c2, c1, c0) dígitos denominados de
control o paridad. Así pues, el nuevo código tendrá una longitud de palabra de
l=n+p. La numeración de los dígitos es la habitual (de derecha a izquierda) pero
comenzando por uno: 

private int[][] matriz; // declaración de la Matriz de Hamming

private String res;
private String devolver="";
private int[] aux;
private int[] actual;
public Hamming() {
res = null;
aux = new int[]{8, 4, 2, 1};
matriz = new int[][]{{0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1}, //
llenado de la Matriz
{0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1}, {0, 1, 1, 0,
0, 1, 1, 0, 0, 1, 1, 0},
{1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}}; // matriz
= new int[4][12];
}
public String getDevolver() {
return devolver;
}
public int XOR(int a, int b) { // La computadora no reconoce 0 y
1 sino el código ASCII
int c = 0; //de los mismos por tanto se
convierten a o y 1
if (a == 48) { //según el código que se
introduzca
a = 0;
 } else if (a == 49) {
a = 1;
}
if (b == 48) {
b = 0;
} else if (b == 49) {
b = 1;
}
if (a != b) {
c = 1;
} else {
c = 0;
}
return c;
}

public int OR(int a, int b) { //Este método si lo que encuentre

devuelve un 1 entre dos
valores siempre cuando no sea 0 y
0 sino devuelve 0 .
int c = 0;
if (a == 48) {
a = 0;
} else if (a == 49) {
a = 1;
}
if (b == 48) {
b = 0;
} else if (b == 49) {
b = 1;
}
if ((a == 0) && (b == 0)) {
c = 0;
} else {
c = 1;
}
return c;
}

public void cambio(int valor) { //Este método si lo que encuentre

es un 1 en el valor
// pasado por parámetro lo cambia
por un 0 y si
if (valor == 1) { lo que encuentra es un 0 lo
cambia por un 1
valor = 0;
} else {
valor = 1;
}
}
public String codificar(String varbinario) { //Codificación de
Hamming tiene por parámetro
 // un arreglo de tipo
String que tiene como
// valores 0 y 1 y
devuelve una cadena
// de String o mensaje
de ejecución
int suma = 0;
/*LLenar la matriz Hamming*/
int M1 = varbinario.charAt(0), M2 = varbinario.charAt(1), M3 =
varbinario.charAt(2),
M4 = varbinario.charAt(3), M5 = varbinario.charAt(4),
M6 = varbinario.charAt(5), M7 = varbinario.charAt(6),
M8 = varbinario.charAt(7);
/*Suma especial entre todos los números de la matriz más
las posiciones de los bit del código ... m1,m2,m3....*/
int C4 = XOR(XOR(M7, M8), XOR(M5, M6));
int C3 = XOR(XOR(M4, M8), XOR(M2, M3));
int g = XOR(XOR(M1, M3), XOR(M4, M5));
int C2 = XOR(g, M7);
int z = XOR(XOR(M1, M2), XOR(M4, M5));
int C1 = XOR(z, M7);
/*Guardar los resultados de la suma XOR en un arreglo*/
actual = new int[]{C2, C2, M1, C3, M2, M3, M4, C4, M5, M6, M7,
M8};
int[] result = new int[]{C4, C3, C2, C1}; /*arreglo de bit de
acarreo*/
for (int k = 0; k < result.length; k++) {
if (result[k] == 1) {
suma += aux[k];
}
}
String temp;
temp=toString();
devolver="";
if (suma > 0) {
cambio(actual[suma - 1]);
res = "Hubo error en el bit de transmisión numero " + suma
+ ",
la cadena devuelta es: " + temp;
} else if (suma == 0) {
res = "No hubo error de trasmisión, la cadena trasmitida
es: " + temp;
}
return res;
}
/*La distancia de Hamming para códigos binarios puede calcularse a
través del peso
de Hamming (WH), que es la cantidad de 1(unos) resultante de la
suma (xor)
entre dos palabras de código*/
/*La distancia mínima de un código lineal es igual al mínimo peso
de sus
palabras distintas de cero*/

public int distanciaMin(String cad1, String cad2) {

 int[] arreglo1 = new int[cad1.length()];// valores de las
cadenas trasmitidas 1
int[] arreglo2 = new int[cad2.length()];// cadenas trasmitidas
2
int[] nuevoAr = new int[arreglo1.length];//resultado del XOR
entre
ambas cadenas
trasmitidas
int cont = 0;
for (int i = 0; i < cad1.length(); i++) {//llenar un nuevo
arreglo con cada
uno de los valores
de la cadena cad1
arreglo1[i] = cad1.charAt(i);
}
for (int j = 0; j < cad1.length(); j++) {//llenar un nuevo
arreglo con cada
uno de los valores de
la cadena cad2
arreglo2[j] = cad2.charAt(j);
}
for (int k = 0; k < arreglo2.length; k++) {//guardar en un
arreglo el resultado
del XOR entre
las cadenas 1-2
nuevoAr[k] = XOR(arreglo1[k], arreglo2[k]);
}
for (int i = 0; i < nuevoAr.length; i++) {
if (nuevoAr[i] == 1) {
cont++;
}
}
return cont;
}
/*decodicar Hamming tiene como parámetro una cadena de String que
pasa por parámetro
y */
public String decodificar(String cadena) {
String result = null;
int bitError = 0;
int[] cadCodif = new int[12];
int[] resultado = new int[4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < cadena.length(); j++) {
cadCodif[j] = OR(matriz[i][j], cadena.charAt(j));
}
int var = 0;
int a = cadCodif[0];
int b = cadCodif[1];
var = XOR(a, b);
for (int j = 2; j < cadCodif.length; j++) {
var = XOR(var, cadCodif[j]);
}
resultado[i] = var;
}
for (int k = 0; k < resultado.length; k++) {
if (resultado[k] == 1) {
bitError += aux[k];
}
 }
if (bitError == 0) {
result = " No hay bit de error ";
} else {
result = "El error esta en en el bit numero " + bitError;
}
return result;
}
@Override
public String toString() {
for (int i = 0; i < actual.length; i++) {
if (actual[i] == 49) {
actual[i] = 1;
} else if (actual[i] == 48) {
actual[i] = 0;
}
devolver += actual[i];
}
return devolver;
}
}