[C] bit shit

[trallallero]

Ho qualche dubbio sullo shift del C

ho un buffer di 128*128 bit, ogni bit corrisponde ad una casella di una matrice 128*128

Devo leggere il buffer e, per ogni bit, se 1 setto la relativa casella della matrice a 1 altrimenti a 0.

Il buffer è unsigned char.

Qual'è il sistema piú efficace ?

grazie

[mad_hhatter]

Originariamente inviato da trallallero

Ho qualche dubbio sullo shift del C

ho un buffer di 128*128 bit, ogni bit corrisponde ad una casella di una matrice 128*128

Devo leggere il buffer e, per ogni bit, se 1 setto la relativa casella della matrice a 1 altrimenti a 0.

Il buffer è unsigned char.

Qual'è il sistema piú efficace ?

grazie

ti conviene fare buf[i][j] && 0x<val> == 0 per testare se in una certa posizione c'è 1 o 0... <val> è tale che la sua rappresentazione binaria contenga tutti 0 tranne un 1 nella posizione desiderata.

spero di aver capito cosa ti serviva, ma non ho capito perchè parlavi di shift...

comunque il titolo mi ha fatto morire dal ridere

[marko.fatto]

Certo che ti stan proprio sulle balle sti bit

[trallallero]

Originariamente inviato da mad_hhatter

ti conviene fare buf[i][j] && 0x<val> == 0 per testare se in una certa posizione c'è 1 o 0... <val> è tale che la sua rappresentazione binaria contenga tutti 0 tranne un 1 nella posizione desiderata.

spero di aver capito cosa ti serviva, ma non ho capito perchè parlavi di shift...

comunque il titolo mi ha fatto morire dal ridere

Originariamente inviato da marko.fatto

Certo che ti stan proprio sulle balle sti bit

ops
vabbè, lapsus, stavo smadonnando

buf[i][j] non va bene perchè il buffer è un array

[mad_hhatter]

Originariamente inviato da trallallero

ops
vabbè, lapsus, stavo smadonnando

buf[i][j] non va bene perchè il buffer è un array

allora leggi buf[i] e scrivi matrice[i / 128][i % 128] dove la divisione è intera!!

[trallallero]

Originariamente inviato da mad_hhatter

allora leggi buf[i] e scrivi matrice[i / 128][i % 128] dove la divisione è intera!!

eh ?

in buf[i] ci sono 8 bits, ognuno corrisponde ad una casella della matrice

[mad_hhatter]

Originariamente inviato da trallallero

eh ?

in buf[i] ci sono 8 bits, ognuno corrisponde ad una casella della matrice

hai ragione, ho scritto la classica stronzata

[Furla]

fammi capire la struttura dati sarebbe unsigned char[128][16]? (16*8=128)
oppure un array su una sola dimensione: unsigned char[2048]? ((128/8)*128=2048)

[trallallero]

allora, spiego meglio e poi posto quello che sto facendo.

Ho un buffer unsigned char lungo 2048 bits.
Il primo bit corrisponde alla casella [0][0] della matrice, il secondo alla [0][1] etc etc. Quindi devo leggere tutti i bits, uno dopo l'altro ed assegnare 1 oppure 0 alla relativa casella

[trallallero]

Originariamente inviato da mad_hhatter

hai ragione, ho scritto la classica stronzata

non l'ho detto io (ma l'ho pensato)

ma è normale, uno pensa di sapere ste cose ma non le usa mai, una volta che le devi scrivere diventa un casino. E non trovo esempi in rete

[mad_hhatter]

leggi buf[i], poi per j che va da 0 a 7 testi il bit j-esimo in buf[i] e scrivi in matrice[i * 8 / 128][(i * 8 % 128) + j]

spero di non aver detto altre cazzate

[mad_hhatter]

Originariamente inviato da trallallero

non l'ho detto io (ma l'ho pensato)

ma è normale, uno pensa di sapere ste cose ma non le usa mai, una volta che le devi scrivere diventa un casino. E non trovo esempi in rete

caspita, so leggere nel pensiero !!!!!!!!!

il fatto è che ti fai una rappresentazione mentale semplicissima che però non corrisponde alle strutture dati in memoria

[trallallero]

Originariamente inviato da mad_hhatter

leggi buf[i], poi per j che va da 0 a 7 testi il bit j-esimo in buf[i] e scrivi in matrice[i * 8 / 128][(i * 8 % 128) + j]

spero di non aver detto altre cazzate

è quello che stavo facendo infatti (a parte il calcolo per le coordinate, grazie ) ma mi sembra un pò laborioso ... magari esiste un metodo migliore

[mad_hhatter]

Originariamente inviato da trallallero

è quello che stavo facendo infatti (a parte il calcolo per le coordinate, grazie ) ma mi sembra un pò laborioso ... magari esiste un metodo migliore

puoi sempre tenere due contatori, uno per la riga e uno per la colonna, da incrementare in modo opportuno

[trallallero]

Originariamente inviato da mad_hhatter

puoi sempre tenere due contatori, uno per la riga e uno per la colonna, da incrementare in modo opportuno

si, preferisco la leggibilitá
alla fine ho fatto cosí:

	
	for( y = 0; y < 128; y++)
	{
		for( x = 0; x < 128; x++, c >>= 1)
		{
			if ((x) % 8 == 0)
			{
				n++;
				c = s[n];
			}
			mat[y][x] = c & 0x01;
		}
		
	}

grazie per il supporto

[mad_hhatter]

Originariamente inviato da trallallero

si, preferisco la leggibilitá
alla fine ho fatto cosí:

	
	for( y = 0; y < 128; y++)
	{
		for( x = 0; x < 128; x++, c >>= 1)
		{
			if ((x) % 8 == 0)
			{
				n++;
				c = s[n];
			}
			mat[y][x] = c & 0x01;
		}
		
	}

grazie per il supporto

bello!
ragionavo dalla prospettiva sbagliata: dal buffer alla matrice... pensando al contrario il codice risulta molto più semplice e leggibile... bravo

[trallallero]

Originariamente inviato da mad_hhatter

bello!
ragionavo dalla prospettiva sbagliata: dal buffer alla matrice... pensando al contrario il codice risulta molto più semplice e leggibile... bravo

beh, grazie ma è frutto anche della collaborazione sul forum

[trallallero]

perfetto, ieri ho fatto le mie funzioni per la matrice, le maschere AND e OR etc etc e ... son cambiate le specifiche (con tanto di litigata col tipo "so tutto io")

non è più una matrice 128 * 128 di interi ma ... di bit.

quindi ho pensato: non faccio una matrice ma un buffer identico a quello che mi arriva così faccio una memcpy e taglio la testa al toro, ma c'è un problema:
il buffer di bit che mi arriva deve essere copiato nel mio buffer passando attraverso 2 maschere di bit (AND e OR) quindi chiedo:
esiste una memcpy speciale che utilizza maschere di bit ?

non so se mi sono capito bene

posso farmela anche da solo ma se esiste già di sistema sicuramente è più veloce