Método de Hamming

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.

Código de HammingEditar

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.

ErroresEditar

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 HammingEditar

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ónEditar

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.

EficienciaEditar

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 solo 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.

DeficienciaEditar

Los Código Hamming tienen la misma dificultad que los códigos de bloque, pues solo 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 JavaEditar

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;
    }
 }

ReferenciasEditar

  1. Códigos detectores y correctores de error. Fundamentos de la Informática (Libro)
  2. Ráfagas de Hamming.Organización de Computadoras.Mg. Javier Echaiz
  3. Trasmisión de Datos.José E Briceno.

Véase tambiénEditar

Enlaces externosEditar