Newsgroup: it.comp.lang.c
Titolo: Lavorare con i bit

Salve,
  Esiste un modo semplice per lavorare con i BIT in C?
Per esempio: leggo 43 bit che ho in memoria, conto gli 1 ... eseguo un 
operazione ... scrivo 12 bit da un'altra parte... e cosě via.
Ovviamente senza utilizzare le stringhe...
Grazie.
Saluti,
Pierluigi
______________________________________________________
Get Your Private, Free Email at 
http://www.hotmail.com
--
Posted from [62.11.122.45] by way of 
law-f265.hotmail.com
 [209.185.130.181] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Esiste un modo semplice per lavorare con i BIT in C? 
  In C non esiste il tipo bit, ne` sono definite costanti binarie.
Tuttavia, e` possibile utilizzare gli operatori sui bit, come &, |,
<<... 
  Con un po' di fantasia si possono ottenere buoni risultati: per,
esempio, se vuoi contare gli "uni" all'interno di un numero, puoi
iterare lo shift destro (>>), controllando l'ultima cifra binaria.
<code>
	unsigned int number=...;
	int counter=0;
	/* while there are 1's in 'number'... */
	while (number) {
		/* if the last binary digit in 'number' is an 1 */
		(number & 1) && counter++;
		/* shift all the the digits one position to right */
		number >>= 1;
	}
</code>
  Le operazioni cosiddette "logiche" sulle architetture CICS come i PC
sono molto veloci, per cui le prestazioni, anche per algoritmi non
ottimizzati (i.e. pensati in fretta e dopo pranzo ;) ), possono
risultare ugualmente soddisfacenti.
  Ricorda di usare interi senza segno per le stringhe di bit, in modo da
evitare le eventuali spiacevolezze dell'aritmetica binaria in
complemento a due.
  Buon divertimento, e...
	Alla prossima,
		marco

 Le operazioni cosiddette "logiche" sulle architetture CICS 
                                                        ^^^^
  CISC, non CICS... L'MVS, se lo conosci, lo eviti... :)
         Alla prossima,
                 marco

Esiste un modo semplice per lavorare con i BIT in C?
  In C non esiste il tipo bit, ne` sono definite costanti binarie.
Tuttavia, e` possibile utilizzare gli operatori sui bit, come &, |,
<<...
  Con un po' di fantasia si possono ottenere buoni risultati: per,
esempio, se vuoi contare gli "uni" all'interno di un numero, puoi
iterare lo shift destro (>>), controllando l'ultima cifra binaria.
<code>
	unsigned int number=...;
	int counter=0;
	/* while there are 1's in 'number'... */
	while (number) {
		/* if the last binary digit in 'number' is an 1 */
		(number & 1) && counter++;
		/* shift all the the digits one position to right */
		number >>= 1;
	}
[...]
______________________________________________________
Get Your Private, Free Email at 
http://www.hotmail.com
--
Posted from [62.11.135.188] by way of 
law-f161.hotmail.com
 [209.185.131.224] 


 bit come fai?
  Come i cari vecchi processori ix86: con piu` registri ed un bel flag
per il carry. Per esempio, puoi utilizzare vettori di interi senza segno
ed estendere le funzioni in modo da operare su questi, eventualmente
conservando in opportune variabili i "resti" delle varie operazioni.
	Alla prossima,
		Marco

operazione ... scrivo 12 bit da un'altra parte... e cosě via.
Con le operazioni logiche e di shift si puo' fare tutto.

 operazione ... scrivo 12 bit da un'altra parte... e cosě via.
Non c'č niente di precostruito. Ti tocca usare le maschere di bit e gli
operatori bit a bit (&, |, ~, ^) e gli shift (>> e <<).
EMG

 marco
Per contare quanti bit sono settati ad "1" all'interno di un numero esiste
un metodo molto piu' efficiente.
Riporto una funzione esempio:
int ContaUni(int x)
{
    int n=0;
    while(x){
        x&=x-1;
        ++n;
    }
    return n;
}
Il tuo procedimento dava come tempo di esecuzione n (n=numeri di bits che
compongono il numero), questo invece SOLO il numero di bit a "1" che
compongono il numero(che puo' essere compreso tra 0 e n). In altre parole
non perdi mai tempo e rischi di guadagnarne parecchio!
Marco, so che il tuo era solo un'esempio, e questa mia risposta non e' per
te, ma per colui che inizialmente ha postato la domanda, perche' abbia piu'
materiale su cui riflettere!
Riflettere fa bene!
Ciao,
Alex




 (criptare, .... cosa???)
Be, diciamo che al mio capo, un giorno gli girano le palle e mi dice che
devo lavorare con 87 bit....
Saluti,
 Pierluigi.

devo lavorare con 87 bit....
Il cui capo farebbe bene a rifarsi agli standard.
Non credo che 87 bit vadano bene per nessuno.

 wrote in message
38fe4c2a...@news.libero.it...

A parte gli scherzi, dai nostri studi e per l'algoritmo che stiamo studiando
87bit č il passo da scrivere sul file sia in lettura sia in scrittura.
Praticamente dobbiamo scrivere 1 bit per il flag, 6 o 7 bit per l'header, 43
bit di dati e il resto sono dati variabili.
Siccome lavoriamo sul *bit*, ci risulta difficile fare alcuni lavori. Per
esempio leggere 45 bit in un dato heap di memoria e restituirci il valore
decimale. Pero' non sappiamo come fare per ordine la parte HIGH con quella
LOW dei bit se raggruppati al piu' di 32 bit.
Scusate se sono stato scontroso, ma qui abbiamo un sacco di problemi!
 Saluti,
 Pierluigi

Scusate se sono stato scontroso, ma qui abbiamo un sacco di problemi!
Scusami tu il tono, ma io non ho mai visto nessuno lavorare su un
numero tale (per di piu' dispari) di bit !


Brevemente diro' cio' che fa il programma:
*Legge un file in memoria.
*Analizza i bit
*Fa alcuni calcoli su di esso
*Scrive i risultati in un'altra zona di memoria (ma in bit, per esempio 1001
11 00 1 di dimensione variabile)
*continua finche' non finisce.
*salva i risultati su file (la parte piu' semplice)
Tu come faresti a usare dei dati a lunghezza variabile in una struttura bit?
Saluti,
 Pierluigi

 *Legge un file in memoria.
^^^^^^^^^^^^^^^^Volevo dire legge un file e lo mette in memoria.

 Tu come faresti a usare dei dati a lunghezza variabile in una struttura
bit?
Se non hai problemi di memoria secondo me ti conviene espandere i bit in
byte in memoria, lavorare comodamente e poi rimpaccarli a 8 a 8 in un byte
(lo avevo fatto qualche tempo fa per fare un block-cipher). Non sarà molto
elegante come soluzione, ma però è +semplice se hai da usare poca memoria
(se lavori a blocchi).
Altrimenti fai delle funzione del tipo
int BitIsSet(unsigned char *ptr,int bit)
{
    int byte_offset=(bit>>3),bit_offset=bit%8;
    ptr+=byte_offset;
    if((*ptr)&(1<<bit_offset))
        return 1;
    else
        return 0;
}
void SetBit(unsigned char *ptr,int bit,int val)
{
    int byte_offset=(bit>>3),bit_offset=bit%8;
    ptr+=byte_offset;
    if(val)
        *ptr|=(1<<bit_offset);
    else
        *ptr&=0xFF^(1<<bit_offset);
}
Ciao.