Simulacion de Comunicacion.

[AlbertoBSD]

El dia de hoy me pidieron ayuda con un trabajo escolar mega-urgente para ayer... como es costumbre  

El programa trata de una simulación de comunicación, supuestamente solo les faltaba la parte que simula RUIDO en el canal de comunicación. Sin embargo realmente les faltaba todo.  

Se me hizo interesante ya que el código solicitado tenia su grado de Dificultad o por lo menos no es un trabajo que le puedan que dejar a alguien que apenas esta aprendiendo a programar.

Hize la parte del RUIDO prescindiendo de todo lo demas ya que se me hacia bastante didáctico.

El codigo lo hize de la forma mas simple y INEFICIENTE, pero trate de que fuera lo mas entendible posible, como hacerlo paso a paso.

Código (c) [Seleccionar] Expandir


#include<string.h> //para memset()
#include<stdio.h> //printf
#include<time.h> //para time auxilizar de rand()
#include<stdlib.h> //Para rand() y srand()

int noise(char *data_stream,int len_data,unsigned char cuantos, unsigned char valor);

int main() {
srand(time(NULL));
char data[50] = {0};
memset(data,'A',50); //Mensajes con puras AAAAAA....
printf("Mensaje antes del ruido:\n%s\n",data);
noise(data,50,10,1); //10 bits con ruido por cada 100 con valor a 1
printf("Mensaje despues del ruido:\n%s\n",data);
}

int noise(char *data_stream,int len_data,unsigned char cuantos, unsigned char valor) {
printf("\nModulo Noise\n");
/*
Recorremos bit a bit y calcular si va a ser o no modificado en base a su probabilidad.
Este método es en base a fuerza bruta y es ineficiente, deben de existir mejores, mas eficiente y de forma matemática, pero dado que se quiere un programa entendible se va a realizar de esta forma.
*/
int i = 0;
int index;
int bit;
int r;
int cantidad_bits = len_data * 8;
while(i < cantidad_bits) {
r = rand() % 100; //Calculamos un numero  "r" aleatorio desde 0 a 99
if(r < cuantos) { //Si el numero "r" es menor que "cuantos" significa que se saco la lotería y a ser sometido a un poco de ruido
index = (int) (i / 8); ////calculamos el index del byte en el que estamos dado el bit
//printf("El byte en el index %i va a ser editado\n",index); //Esta función puede ser descomentada para depurar y entender como funciona esta funcion
bit = i % 8; // Aqui calculamos el bit que tiene que ser modificado en el byte marcado por el index previamente calculado
if(valor) { //Si valor es 1, establecemos el bit en la posición "bit" a 1 del Byte dado por el index de la data
data_stream[index] |= 1 << bit;
}
else { // Si es 0, hacemos el proceso opuesto y lo seteamos en 0 en bit en la posición "bit" del index de la data
data_stream[index] &= ~(1 << bit);
}
}
i++;
}
}


El código trabaja directo sobre un apuntador que contiene los datos, pero podría trabajar byte por byte con sus respectivos cambios.

El programa funciona bien.



Parte de lo que me pedían era lo que esta en la siguiente imagen, pero realmente les faltaba todo....

[CalgaryCorpus]

floor() es superfluo. La division de enteros da entero siempre.

Sugiero revisar la logica, pues el codigo no parece calzar con lo que se pide.

"cuantos" deberia indicar cuantos bits modificar cada 100 bits, pero el codigo modifica los primeros "cuantos" bits, no es lo mismo.

Dicho en numeros:
no es lo mismo modificar 3 bits aleatoriamente, que modificar los primeros 3 bits.

[AlbertoBSD]

Eso esta mal lo que dices

"cuantos" deberia indicar cuantos bits modificar cada 100 bits, pero el codigo modifica los primeros "cuantos" bits, no es lo mismo.

El programa modifica bits al azar tal como lo muestra la imagen.



Si es cierto lo que dices del floor, lo cambiare, como tal lo mencione lo trate de hacer lo mas simple posible para que cualquier persona sin tantos conocomientos en C lo pueda entender.

Saludos

[CalgaryCorpus]

Mira la descripcion que mandaste:

a) cuantos bits con ruido por cada 100 bits.

no es lo que haces.

[AlbertoBSD]

Si es lo que hago.En base a probabilidad esta comentado el la siguiente parte del codigo

Código [Seleccionar] Expandir

r = rand() % 100; //Calculamos un numero  "r" aleatorio desde 0 a 99
if(r < cuantos) { //Si el numero "r" es menor que "cuantos" significa que se saco la lotería y a ser sometido a un poco de ruido


Formas de hacerlo hay varias no te cierres solo a una, yo elegi por probabilidad.

Si r  un numero al azar de 0 a 99 es menor que que cuantos significa que le toco a ese bit ser modificado.

Si fuera cierto que solo modifico los primeros "cuantos" bits el mensaje solo tuviera las primeras letras A modificadas. pero es al azar.

Saludos

[CalgaryCorpus]

Para entender lo que tu crees que estas haciendo, comparado con lo que se pide:

Si "cuantos" tiene valor 1, y tienes 100 bits en total.

cuantos bits tienes que modificar de esos 100 bits?

yo digo que tienes que modificar 1 de ellos, aleatoriamente elegido, y no es lo que haces.

El que muestres que los datos han sido modificados, no implica que las modificaciones estan bien hechas.

[AlbertoBSD]

Imagina que solo nos mandan un BYTE, esto es 8 bits claro.

Y el ruido esta seateado a que 10 de cada 100 sean modificados.

Esto significa que en esos 8 bits puede ser que uno de ellos se modifique,  o puede que no este modificado, por que hay  2 bits que faltan para completar los 10, entonces como elegir si de esos 8 uno va a ser modificado o no?, pues yo prefiero algo al azar.

Formas de abordar el problema hay varias. Se que hay mejores y mas eficientes, pero en este ejemplo lo aborde de manera probabilistica y no determistica. Pienza en el ejemplo anterior de que nos manden solo 8 bits. como decides si uno de ellos se debe de modificar o no?

El que muestres que los datos han sido modificados, no implica que las modificaciones estan bien hechas.

Si claro, hace 2 post afirmabas que solo modificaba lo primeros cuantos bits.

[CalgaryCorpus]

Repito, porque decidiste ignorar la pregunta:

Si "cuantos" tiene valor 1, y tienes 100 bits en total.

cuantos bits tienes que modificar de esos 100 bits?
cuantos modificas?

[AlbertoBSD]

En ese caso la probabilidad dicta que solo 1.

Y tu decidiste ignorar mi pregunta de solo 8 bits. Asi que estamos a mano.

Elegi al azar y por probabilidad ya que en mi opinion es la mejor forma de simular el ruido o interferencia en una comunoicacion. fuentes de ruido hay muchas y dependiendo de la fuente de ruido, no se, un motor en funcionamiente puede meter ruido a frecuencia constante, pero esto no es asi si viene de otro tipo de fuente, por ejemplo un coro circuito podria dar un patron de ruido muy inconstante. Un automovil pasando de vez en cuando tambien lo es.

Si es cierto, no hago lo que el programa pide, pero en lo que se refiere a la simulacion de ruido creo que no esta mal y si es por probabilidad es muy cercano a lo que el programa esta pidiendo.

Tambien lo hize asi para poder solventar el problema de eligir si modificar o no uno o alguno de los 8 bits del ejemplo mas sencillo.

Te mandan solo 8 bits y el ruido esta seteado a solo 1 de cada 100, ¿Como elegir si determinado bit debe de ser modificado o no?

Confio en que la funcion de probabilidad va a ser algo muy parecido a lo que pide, si aun que no sea lo mismo.



En algun punto el programa pide que el modulo se incluya en el canal de comunicación. He reescrito la funcion de ruido par que solo trabaje un BYTE a la vez.

Código (c) [Seleccionar] Expandir

#include<string.h>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

#define LEN 12

char noise(char byte,unsigned char cuantos, unsigned char valor);

int main() {
srand(time(NULL));
char data[LEN+1] = {0}; //LEN + uno por aquello del byte terminacion de cadena.
int i = 0;
memset(data,'A',LEN);
printf("Mensaje antes del ruido:\n%s\n",data);
while(i < LEN) {
data[i] = noise(data[i],1,1);
i++;
}
printf("Mensaje despues del ruido:\n%s\n",data);
}



char noise(char byte,unsigned char cuantos, unsigned char valor) {
int i = 0;
while(i < 8) {
if((rand() % 100) < cuantos) {
if(valor) {
byte |= 1 << i;
}
else {
byte &= ~(1 << i);
}
}
i++;
}
return byte;
}



Para demostrar que la aproximación por probabilidad es muy aproximada a lo que se esta pidiendo he vuelto a modificar el programa, indicando solamente el Ratio de bits modificados contra recibidos.

Salida el programa con 10 millones de BYTES de datos Enviados

Código [Seleccionar] Expandir



Valores enviados 80000000, modificados 800351, ratio 0.010004
C:\codigos>comunicacion.exe
Valores enviados 80000000, modificados 799396, ratio 0.009992


Si vien vemos es casi siempre un valor cercano al 1 por ciento

Codigo

Código (c) [Seleccionar] Expandir


#include<string.h>
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

#define LEN 12

char noise(char byte,unsigned char cuantos, unsigned char valor);

unsigned int recibidos = 0;
unsigned int modificados = 0;

int main() {
unsigned int i = 0;
srand(time(NULL));
while(i < 10000000) {
noise('A',1,1);
i++;
}
printf("Valores enviados %u, modificados %u, ratio %f",recibidos,modificados,(float)modificados/(float)recibidos);
}

char noise(char byte,unsigned char cuantos, unsigned char valor) {
int i = 0;
recibidos+= 8;
while(i < 8) {
if((rand() % 100) < cuantos) {
modificados++;
if(valor) {
byte |= 1 << i;
}
else {
byte &= ~(1 << i);
}
}
i++;
}
return byte;
}



Saludos.

[CalgaryCorpus]

La manera de probar que el codigo original es cercano a lo que se pide no esta bien.
El test solo muestra que la funcion de probabilidad te sirve, no que su uso esta bien,

Recuerda que tienes que modificar a lo mas <cuantos> bits por cada 100 de ellos.
Esto no te lo da la solucion propuesta, porque usas la probabilidad en tamanos distintos de 100 (aunque usas el 100 para controlar si aplicar el cambio o no al bit visitado), por lo que es bien posible que se modifiquen mas que <cuantos> bits, como te ocurre. Contabilizar los cambios para corregir esto solamente va a tener bias favoreciendo a los primeros cambios.

Si modificas tu funcion noise original, para avanzar a traves del conjunto de caracteres cada 100 bits, aun usando la funcion de probabilidad, tu resultado sera mas cercano al correcto, nunca modificando mas de los bits que son necesarios.

Mucha teoria, lo que indico, usando parte de lo que enviaste, corrigiendo de acuerdo a lo que propongo.

Código (c) [Seleccionar] Expandir


int noise(char *data_stream,int len_data,unsigned char cuantos, unsigned char valor) {
int index;
int bit;
int offset;
int bit_offset;
int bits_modificados;
int cantidad_bits = len_data * 8;

for(int offset = 0; offset < cantidad_bits; offset += 100) {
    for( bits_modificados = cuantos; bits_modificados > 0; bits_modificados--) {
      bit_offset = rand() % 100 + offset;
      if( bit_offset > cantidad_bits) {
          continue;
}
    index = bit_offset / 8;
    bit = bit_offset % 8;
    if(valor) {
   data_stream[index] |= 1 << bit;
} else {
                    data_stream[index] &= ~(1 << bit);
}
       }
}
}


Lo pruebas asi:

Código (c) [Seleccionar] Expandir


#define LARGO 100 // 1 cambio cada 100 bits seran 8 cambios en total (a lo mas).

int main() {
srand(time(NULL));
char data[LARGO+1] = {0};
for( int test = 0; test < 100; test++ ) {
           memset(data,0,LARGO);
   noise(data,LARGO,1,1);
           // lo correcto es contar los bits modificados, pero si tenemos suerte
           // solo se ha modificado 1 bit por caracter
   int count = 0;
   for(int i = 0; i < LARGO; i++) {
       if(data[i] != 0) {
           count++;
       }
   }
   printf("Mensaje despues del ruido: %d modificaciones\n", count);
}
}