SoloCodigo

Hola gente!!!!!!!!!

Estoy haciendo una clase (C++) que a partir de un long convierte ese numero a codificacion GAMMA, usada para codificar numeros en indexacion (es una forma de comprimir informacion). Les doy un ejemplo de Gamma:

6 en base decimal a Gamma:

log(6) = 2        //log en base 2 redondeado para abajo
2 + 1 = 3  entonces represento este tres en unario:
"110" en unario = 3 en decimal
X- 2^log|X| = 8 - 2^3 = 8 - 8 = 0 entonces represento el 0 en log|X| bits en binario, entonces 0 en base 10 = 00 en base 2 en 2 bits entonces:

8 (en base 10) = 110 00 (en gamma)

Bueno, como veran tengo q trabajar a nivel de bits, cosa q no he hecho jamas. Tengo claro q a la hora de guardar bits, si o si los tengo q guardar en grupos de 8 bits (1 byte) y eso implica mas bits a llenar en el byte.
El problema viene por este lado, yo puedo resolver el metodo sin ningun problema, pero la pregunta es donde voy guardando los bits. Se entiende q si lo guardo en un short (2 bytes "supuestamente") estoy desperdiciando bits (o no dependiendo si tengo mas de 16 bits), entonces mi idea seria guardar los bits en un buffer, pero no se de q tipo tiene q ser ese buffer. Eso es lo q quiero q alguien me diga, mi buffer, de q tipo debe ser???? Hay algun tipo de dato q me ayude con esto????

Salu2!!!!!

Hola.

Que yo sepa no hay ningún tipo de datos que ocupe un solo bit. El más apropiado para ello sería bool, pero ocupa un byte. Lo que he visto hacer en estos casos es coger un array de char e ir accediendo al bit que quieras posicionandote primero en el array y aplicando una máscara para obtener el bit deseado (esto es lo que se hace con el FD_SET que usa el select() en linux, con macros). Así no desperdicias nada de espacio, pues usas los 8 bits de cada char.

También podrías acceder a cada uno directamente con un campo de bits:

Un saludo.

Ruben3d

Hola,
 

Lo que se me acaba de ocurrir.

yo guardaria cada bit en un char como decia Ruben3d.

y estos char formarian un arreglo.

seria:


vas guardando los bits en cada elemento del arreglo;

algo como:


cuando se llene el arreglo lo vuelcas en una variable de tipo char
con operadores como '<<' , '>>' , |  o &.

algo como:


la ultima or la podrias hacer también como:


pero tarda un poco más.

Despues solo tienes que ir metiendo los char (data) en un buffer mayor como una pila o lo que necesites.

es solo una idea.

yo he trabajado con los operadores '|', '&', '<<' y '>>' para crear un driver de una camara que recibia streams de bits y me funcionaron perfectos.

Espero haberte sido util. Por favor dime i funciono ¿ok?

saludos

               

Ruben3d!!

Si la quiero a esa info y no te entendi bien lo de FD_SET. Mire en las man pages ( a traves de google.com/linux) y no entendi q es y como se usaria. Si tuvieras un minimo ejemplo, yo lo sigo. No es de vago q no lo quiero hacer, no tengo idea de como hacerlo

Salu2!!!!!

Yo hice un algoritmo de compresión mediante prefijos: La idea es recodificar cada byte en un prefijo único que puede tener n bits. Los bytes más frecuentes tendrán prefijos más cortos y los menos frecuentes prefijos más largos. No es necesario que cada nueva codificación tenga tamaño fijo por que son prefijos únicos y no existe ambiguedad al leerlos.

Al grano:

- Tienes que crear un funcion que almacene en un bloque de memoria n bits de por ejemplo un entero de 32bits, suponiendo que nunca tendrás un código de más de 32 bits. (más adelante lo detallo)

El problema es que sólo lo podrás leer secuencialmente, lo que no es problema para un algoritmo de compresión. Si necesitaras acceder en todo momento a cualquiera de los valores codificados y además necesitas saber la longitud en bits de cada código no te queda mejor remedio que desperdiciar bits y además agregar un byte extra para indicar el tamaño en bits del código:
un arreglo de int para el codigo (si no pasará de 32 bits) y otro de char para el tamaño.

Para almacenar códigos de n bits que sean prefijos únicos como usualmente ocurre en ese tipo de compresión (no sirve si es necesario saber la longitud de cada código de n bits):
==============================================0

Tienes que tener buffers de todo tamaño, en general:

1er buffer: un entero de 32 bits. (Registros)
2do buffer: un pedazo de memoria de digamos 64kb o lo que necesites o veas conveniente, si al final guardarás los datos en disco 64Kb no estarán nada mal (RAM)
3er buffer: si es necesario guardar en disco, un archivo abierto listo para guardar información. (DISCO)

La idea es esta:

- Coges el número entero y sabes cuantos bits tienes que extraer y almacenarlos en el buffer.
- Ves si en tu buffer de 32 bits existe espacio suficiente, si existe lo agregas usando desplazadores << >> para posicionar los bits en el lugar adecuado y los colocas con el operador de bits "or" |.
- Si no existe espacio suficiente tienes que partir en dos el código, guardar el pedazo que entra en el buffer y luego guardar el pequeño buffer de 32 bits en el buffer mayor, luego limpias el buffer de 32 bits y colocas el resto del código que faltaba colocar en buffer.

Lo mismo para los otros buffers:

Cuando se llene el buffer de 64 kb (ejemplo), guardarlo en disco y limpiar el buffer de 64Kb, luego agregar al buffer limpio lo que faltó guardar al momento que el buffer se llenó.