[1] Comentário enviado por matux em 20/05/2009 - 21:39h

Parabéns, mto útil!
Alias, sempre útil essas dicas de conversão!

0 0

[2] Comentário enviado por rndrama em 21/05/2009 - 09:54h

INTERESSANTE!!! PARABÉNS!!!! Fiz uma aplicação básica que demonstra a construção da matriz de Hamming, depois inserir uma rajada de erro e posteriormente corrir este. Usei as conversões citadas acima. Segue código......

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define N 51

void corrigeErro(char *str, int matriz[50][11], int lin_rajada, int tam_rajada);
int paridade(int num);
int verificaParidade(int matriz[50][11], int vet[4][5], int i, int cont, int insere_ou_verifica, int j);
int potenciaDois(int aux_col);
void converteMatrizString(int matriz[50][11], int insere_erro_ou_imrime_string);
int insereBitsParidade(int matriz[50][11], int insere_ou_verifica, int lin, int col);
int retornaLinhaVet(int j);

int main()
{
//size - pegamos tamanho da string
//ind_str - indice do vetor str
//vet - vetor que vai contabilizar a quantidade de vezes que as potências de dois aparecem
// nas somas dos seguintes números: 3,5,6,7,9,10,11(números de 1 a 11, exceto potências de
// dois);
// posição 0 informa a quantidade de vezes que o expoente zero aparece nas somas;
// posição 1 informa a quantidade de vezes que o expoente um aparece nas somas;
// posição 2 informa a quantidade de vezes que o expoente dois aparece nas somas;
// posição 3 informa a quantidade de vezes que o expoente tres aparece nas somas;


int size, num_dec, lin = 0, col = 11,
resto, ind_str = 0, matriz[50][11],
teste, aux_col, flag = 1,
vet[4] = {0, 0, 0, 0}, i,;

int insere_ou_verifica = 1, ret_paridade, insere_erro_ou_imrime_string = 1;

char str[N] = "Trabalho de Redes I analisando a Matriz de Hamming";


size = strlen(str);

while(size >= 0)
{

num_dec=(int)str[ind_str];

while(col > 0)
{
if(flag)
{
resto = num_dec%2;

num_dec = num_dec/2;

}

if(potenciaDois(col))
{
flag = 1;

matriz[lin][col]=resto;
}
else
{
flag = 0;

//só com o cinco que dar certo; nao sei pq
matriz[lin][col]=5;
}

col--;

}

size--;

ind_str++;

lin++;

col = 11;

flag = 1;

}

//insere_ou_verifica define o que a função insereBitsParidade vai fazer, inserir ou verificar e
//lin vai definir a linha da matriz
lin = 0;
col = 1;

ret_paridade = insereBitsParidade(matriz,insere_ou_verifica,lin,col);

printf("Questao (A): Matriz de Hamming para a String passada!!!!\n\n");

printf(" ");

for(col=1; col<=11; col++)
printf("%d ", col);

printf("\n");

for(lin=0; lin<50; lin++)
{
printf("%c ", str[lin]);

for(col=1; col<=11; col++)
printf("%d ", matriz[lin][col]);

printf("\n");
}

printf("\n\nQuestao (B): Inserir erro, Imprimir String com erro e corrigida!!!!\n");

//Insere Erro e converte a matriz em String
converteMatrizString(matriz,insere_erro_ou_imrime_string);

printf("\n\nOBS Questao (C): Favor descomentar linha 299(//tam_rajada = 50;) para rodarmos com a rajada 50!!!!\n\n\n\n");

system("PAUSE");
return 0;
}

//retorna 1 se o número passado não seja potência de dois, 0 caso seja
int potenciaDois(int aux_col)
{
int flag = 0;

while(aux_col != 1)
{
if(aux_col%2)
flag = 1;

aux_col = aux_col/2;
}

return flag;
}

//Insere conteúdo nos bits de paridade, levando-se em conta a paridade par(insere 1 se a soma dos
//conteúdos dos bits de dados, não potência de dois, for ímpar, insere 0 caso a soma seja par)
int insereBitsParidade(int matriz[50][11], int insere_ou_verifica, int lin, int col)
{

/*
+++++++++++++++++++++++++++++++++
EXPLICAÇÃO DE ALGUMAS VARIÁVEIS
+++++++++++++++++++++++++++++++++
1 - vet: Vai armazenar os bits, cuja soma aparecem as potências de dois(vai determinar o valor
dos bits de paridade, ou seja, os bits potência de dois)
EX:
Expoentes: 1 = 2º / 2 = 2¹ / 4 = 2² / 8 = 2³
Somas: bit 3 = 1 + 2
bit 5 = 1 + 4
bit 6 = 2 + 4
bit 7 = 1 + 2 + 4
bit 9 = 1 + 8
bit 10 = 2 + 8
bit 11 = 1 + 2 + 8

Logo, observa-se que a potência 2º(1) acontece 5 vezes nas somas, nos bits 3,5,7,9 e 11.
Esse raciocínio também é verificado para as outras potências
Nesse sentido, criamos o vetor vet para armazenar tais posições.
2 - ret_paridade: vai receber paridade do bit
*/

int vet[4][5] = {
{3,5,7,9,11},
{3,6,7,10,11},
{5,6,7},
{9,10,11}
};
int i, j, aux_lin_vet, ret_paridade;


for(i=lin; (i<50 && insere_ou_verifica) || (i<lin+1 && !insere_ou_verifica); i++)
{

for(j=col; (j<=11 && insere_ou_verifica) || (j<col+1 && !insere_ou_verifica); j++)
{

if(!potenciaDois(j))
{

aux_lin_vet = retornaLinhaVet(j);

if(insere_ou_verifica)
matriz[i][j] = verificaParidade(matriz, vet, i, aux_lin_vet,insere_ou_verifica,j);
else
ret_paridade = verificaParidade(matriz, vet, i, aux_lin_vet,insere_ou_verifica,j);

aux_lin_vet++;

}

}

//precisamos da paridade do bit a cada linha na verificação
if(!insere_ou_verifica)
return ret_paridade;

}

return ret_paridade;

}

int verificaParidade(int matriz[50][11], int vet[4][5], int i, int aux_lin_vet, int insere_ou_verifica, int j)
{
int cont = 0, lin, col, ja;

for(lin = aux_lin_vet; lin < aux_lin_vet + 1; lin++)
{

for(col=0; col<5; col++)
{

if(matriz[ i ][ vet[lin][col] ] == 1)
cont++;

}

}

return paridade(cont);
}

//Retorna 1 se número passado é impar, e 0 caso par
int paridade(int num)
{
if(num%2)
return 1;
else
return 0;
}



int retornaLinhaVet(int j)
{
int aux_lin_vet = 0;

if(j == 2)
aux_lin_vet=1;
else
if(j == 4)
aux_lin_vet=2;
else
if(j == 8)
aux_lin_vet=3;

return aux_lin_vet;
}

/*
========================================================================================
RESOLUÇÃO DA QUESTÃO B - RECEBE UMA MATRIZ E RETORNA(IMPRIME) UM VETOR DE CARACTERES
========================================================================================
*/

void converteMatrizString(int matriz[50][11], int insere_erro_ou_imrime_string)
{

/*
+++++++++++++++++++++++++++++++++
EXPLICAÇÃO DE ALGUMAS VARIÁVEIS
+++++++++++++++++++++++++++++++++
1 - quant_bits: Vai ser o expoente das potências de dois, como vai achar n bits inicializamos de
de -1 para podermos pegar n-1(vai incrementar) potências de 2(expoentes de 0 a n-1)
*/

int lin, col, quant_bits = -1, num_dec_convert, aux_quant_bits,
lin_rajada, col_rajada, tam_rajada, troca_bit, bck_tam_rajada;
char str[N];
float temp, num_dec;

srand(time(NULL));


if(insere_erro_ou_imrime_string)
{
lin_rajada = 0 + rand() % 50;

col_rajada = 1 + rand() % 11;

tam_rajada = 1 + rand() % 50;

//==========================================================
//QUESTÃO C: para rodar a questão c só é descomentar a linha abaixo(tam_rajada = 50)
//==========================================================
//tam_rajada = 50;

bck_tam_rajada = tam_rajada;

printf("\n\nO tamanho da rajada foi %d, a linha foi %d e a coluna foi %d\n", tam_rajada,
lin_rajada, col_rajada);

for(lin=lin_rajada; (lin<50 || lin<lin_rajada) && tam_rajada>0; lin++)
{

troca_bit = matriz[lin][col_rajada];

troca_bit = paridade(!troca_bit);

matriz[lin][col_rajada] = troca_bit;

tam_rajada--;

if(lin == 49)
lin = 0;

}
}

//descobre quantidade de bits
for(col=1; col<=11; col++)
if(potenciaDois(col))
quant_bits++;

//conservar a quantidade de bits
aux_quant_bits = quant_bits;

//convertemos o valor binário em decimal(somas sucessivas de potências de dois) e inserimos no
//vetor de caracteres
for(lin=0; lin<50; lin++)
{

num_dec = 0;

for(col=1; col<=11; col++)
{

//bits que contém os dados; todos aqueles não potência de dois
if(potenciaDois(col))
{

//bit com valor 1, fazemos a soma sucessiva
if(matriz[lin][col])
{
temp = pow(2,quant_bits);

num_dec = num_dec + temp;
}

quant_bits--;

}

}
//atualiza valor da quantidade de bits
quant_bits = aux_quant_bits;

//converte o valor float achado, após a conversão de binário, para int
num_dec_convert = (int)num_dec;

//converte o valor int ao caractere correspondente levando em conta a Tabela ASCII e insere
//o caractere no vetor
str[lin] = (char)num_dec_convert;

}

printf("\n\n");

//Impressão do vetor de caracteres formado
for(lin=0; lin<50; lin++)
printf("%c", str[lin]);

printf("\n\n");

if(insere_erro_ou_imrime_string)
corrigeErro(str, matriz, lin_rajada, bck_tam_rajada);

}

void corrigeErro(char *str, int matriz[50][11], int lin_rajada, int tam_rajada)
{
int insere_ou_verifica = 0, insere_erro_ou_imrime_string = 0, acumula_soma = 0,
i, j, ret_paridade, troca_bit;

for(i=lin_rajada; (i<50 || i<lin_rajada) && tam_rajada>0; i++)
{

for(j=1; j<=11; j++)
{

if(!potenciaDois(j))
{

ret_paridade = insereBitsParidade(matriz,insere_ou_verifica,i,j);

if(ret_paridade != matriz[i][j])
acumula_soma = acumula_soma + j;

}

}

troca_bit = matriz[i][acumula_soma];

troca_bit = paridade(!troca_bit);

matriz[i][acumula_soma] = troca_bit;

acumula_soma = 0;

tam_rajada--;

if(i == 49)
i = 0;

}

converteMatrizString(matriz,insere_erro_ou_imrime_string);

}

0 0

[3] Comentário enviado por zecnikis em 26/05/2009 - 20:48h

Otimo artigo para quem esta começando.
O Básico do básico!
Mas com prática não tem erro!

Até mais!

0 0

[4] Comentário enviado por removido em 30/08/2009 - 01:53h

Show.

0 0

[5] Comentário enviado por julio.ferraz em 05/01/2012 - 16:45h

Ótima Explicação! Ainda mas pra quem tá relembrando..ou ainda...não sabe..obrigado!

0 0