Operazioni sui bit

[Picavbg]

Nello studio che sto svolgendo sono incappato sulle funzioni di trattamento dei bit che compongono un valore. Ho trovato nella "A Beginner's Guide to Gambas" un capitolo dal titolo "Bit Operation" con tanto di esempio pratico. Ho allora voluto provare il programmino di esempio per conoscere meglio le funzioni disponibili (BTst, BClr, BSet, BChg, Shl, Shr, Rol, Ror). Dopo avere provato e capito le funzioni "BClr, BSet, BChg", ho provato anche "Shl", però ho risconrato differenza fra quanto detto nella guida, nello specchietto di pag.319 e quanto detto poi nell'esempio dio pag.322. Infatti nello specchietto, relativamente ad "Shl" é detto:

Shl Value = Shl(Number , Bit)  Returns operand1 with the bit specified in operand2  shifted left one bit position.

che credo voglia dire: "Restituisce operand1 con il bit specificato in opernd2 slittato a sinistra di una posizione

per cui se operand1 contiene "00010100" e operand2 contiene "2" il risultato prodotto da Shl dovrebbe essere "00101000".

A pag.322 leggo:

      The   Shl   function   is   will   shift   the   value   of  MyInt  n  bits   left   where  n  is
specified by the second parameter.

che credo voglia dire: "la funzione "Shl" svolge lo slittamento del valore di MYiInt(operand1) di n bit a sinistra dove n"n" è specificato dal secondo parametro (operand2).

ho eseguito la prova partendo da operand1=10010110 e operand2=3 il risultato é stato: "10010110000" cioè esattamente quello spiegato nell'esempio.

.
[/quote]
Purtroppo non conosco il linguaggio "C" e non posso trovare , se esiste, la corrispondente funzione.
La discordanza riscontrata, se non ho capito male, é da attribuire ad un errata spiegazione nella guida o, piuttosto, é proprio sbagliato il risultato che fornisce la funzione?
In ogni caso credo che bisognerebbe segnalare l'anomalia a Benoît Minisini.
 :hammer:
Ciao.

[leo72]

Le funzioni sui bit avevano dei bug e sono state corrette in una delle ultime versioni di Gambas.
Quindi, intanto sarebbe interessante sapere quale versioni usi.

Detto questo, le funzioni sui bit operano in questo modo:
SHL(numero, spostamento): scorrimento a sinistra (SHift Left) di "spostamento" numero di posizioni i bit del numero "numero".
SHR(numero, spostamento):  scorrimento a destra (SHift Right) di "spostamento" numero di posizioni i bit del numero "numero"

Da tener presente che lo scorrimento implica la "scomparsa" dei bit che escono dal registro. Quindi, se vai a scorrere a sinistra il byte "10000000" di 1 bit, otterrai "00000000".

L'altra operazione fondamentale sui bit è la rotazione, effettuata dalle funzioni ROL (ROtate Left) e ROR (ROtate Right). A differenza dello scorrimento, però, la rotazione implica che i bit che escono dal registro da una parte ricompaiono dall'altra. Mi spiego...
Se ruoti a sinistra di 3 bit il valore "11100000" otterrai "00000111".

Detto questo, vanno tenute in considerazione alcune cose:
1) devi considerare che queste operazioni possono essere eseguite solo su numeri interi del tipo byte, short, integer e long, e che la "scomparsa" dei bit nello scorrimento o la rotazione dipende dalla lunghezza del tipo di numero. Se usi un byte, hai 8 bit ecc...
2) Gambas non ha il tipo "unsigned" per cui nelle operazioni devi sempre tener conto di questo. Esistono infatti 2 funzioni apposite che scorrono i numeri tenendo conto del segno, LSL e LSR, rispettivamente per scorrere a sinistra e per scorrere a destra.

Per tutto il resto fai riferimento alla documentazione ufficiale:
http://gambasdoc.org/help/cat/bit

Tieni cmq presente che le operazioni sui bit in Gambas non sono certo facili e spesso bisogna operare delle "manipolazioni" per ottenere gli stessi risultati del C (me ne sono accorto io convertendo algoritmi di cifratura da C a Gambas, algoritmi che nella stragrande maggioranza dei casi contemplano operazioni a livello di bit).

[Ceskho]

Per la modifica di singoli bit in programmi che ad esempio modificano solo dati espressi in byte è possibile usare un metodo definito "con maschera".....mi spiego meglio....hai un numero binario 10000100 e vuoi controllare lo stato del sesto bit (il terzultimo) usi una "mashera", ovvero un numero di tanti bit quanti quello che vuoi esaminare (nel nostro caso 8) con un 1 nella posizione del bit da controllare....dopodichè si analizza il valore che viene restituito da una AND tra i due numeri.....nel nostro caso la maschera sarà 000000100 e l'operazione

10000100 AND 000000100

Se il bit in analisi e 0 si otterà un 0000000000 che in molti linguaggi di programmazione (come il C) vale 0 poichè tutti i bit valgono tanto, altrimenti si ottiene 00000100 che nel C viene riconosciuto come 1 (in quanto tutto ciò che non è 0 è 1).

In questo modo è possibile usare una maschera per modificare il valore di un dato numero...se vuoi che uno specifico bit diventi zero fai una AND con tutti i valori 1 tranne lo 0 nella posizione voluta oppure il contrario....

spero di essere stato chiaro..nel caso chiedi pure....

[Picavbg]

leo72 ha scritto:
Le funzioni sui bit avevano dei bug e sono state corrette in una delle ultime versioni di Gambas.
Quindi, intanto sarebbe interessante sapere quale versioni usi.

Avevo immaginato quello che mi hai confermato con la tua risposta; solo che il malfunzionamento di alcune delle funzioni che trattano bit persistono ancora alla versione 2.9.0 che è l'unica che ho installato. Le funzioni che "... non funzionano" sono Shl, Rol, Ror, BTst. Stando le cose come mi hai detto non vale neanche la pena che entri nei dettagli delle anomalie riscontrate.

leo72 ha scritto:
Detto questo, le funzioni sui bit operano in questo modo:
.............................

Si, tutto vero. Leggendo il manuale "A Beginner's Guide to Gambas", ho capito benissimo il la logica del funzionamente teorico delle funzioni Gambas sui bit, ma se manipolo con le funzioni Shl, Shr, Rol, Ror un campo grande 1 byte(8 bit), il risultato dopo la manipolazione non può tradursi nell'ottenimento di un campo da 4 byte o più. Quindi, se con le versioni successive alla 2.9.0 il bug é stato risolto, fai fintta di niente; io purtroppo in questo momento non posso verificarlo perchè aspetterò ancora un pò prima di passare ad una versione più recente.

Ceskho ha scritto:
Per la modifica di singoli bit in programmi che ad esempio modificano solo dati espressi in byte è possibile usare un metodo definito "con maschera".....

Grazie per il cortesissimo suggerimento. Sono pienamente d'accordo con te dato che quello che mi hai suggerioto è un metodo che conosco perchè l'ho imparato quando ho cominciato a programmare, lavorando qualche volta anche in assembler.

Il bello del Forum è che le discussione non sono circoscritte ai diretti partecipanti, ma quello che viene richiesto, proposto, indicato, suggerito o consigliato, è materia utile anche a chi affronterà l'ostacolo, se così posso dire, più avanti e, risalendo a quanto è stato già speso prima da altri amici del Forum, può facilmente trovare aiuto senza chiedere. Anch'io ho superato certi pit-stop con tale metodo. Comunque, grazie. :-)  :-)
:ciao:  :ciao:

[leo72]

La 2.9 dovrebbe essere esente dai bug. Dal changelog (che ho ricontrollato) le operazioni sui bit sono state sistemate nella 2.8.2.

ma se manipolo con le funzioni Shl, Shr, Rol, Ror un campo grande 1 byte(8 bit), il risultato dopo la manipolazione non può tradursi nell'ottenimento di un campo da 4 byte o più.

Beh, questo è logico: se stai manipolando un byte, ottieni un byte. Per la trasformazione da byte ad intero (4 byte di lunghezza), devi operare a livello di codice.
Potresti ad esempio scrivere

Codice: [Seleziona]

RisultatoIntero = &H000000 OR ValoreByte

[Picavbg]

leo72 ha scritto:
La 2.9 dovrebbe essere esente dai bug. Dal changelog (che ho ricontrollato) le operazioni sui bit sono state sistemate nella 2.8.2.

Come ho detto all'inizio della discussione, ho soltanto costruito un piccolissimo programma inserendovi le istruzioni di utilizzo delle varie funzioni sui bit indicate nella guida "A Beginner's Guide to Gambas", a partire da pag.318. Dopo avere caricato le istruzioni ho eseguito il programma e per quanto riguarda la funzione "Shl" ho digitato il numero 197, impegnando così 8 bit (vedi allegato n.1). Poi ho inserito nella casella (scegli un bit (1-8)) il bit numero 3. Se condo quanto letto nel manuale, avrei dovuto ottenere lo slittamento di una posizione a sinistra di tutti bit a partire dal bit prescelto (il bit con progressivo 2). Invece come è possibile vedere dall'allegatio n.2, il campo originario è stato alterato ed è diventato di due byte con un risultato completamente inaspettato (1576).
Da tutto ciò devo ritenere che la versione 2.9.0 di Gambas contenga ancora i bug cui hai accennato prima tu.
Io ancora non ho nemmeno provato ad usare nessuna delle funzioni sui bit, perchè era mio desiderio ed interesse capirne prima l'applicazione nel liguaggio; però lo studio è andato a ... pallino.
Spero di essere stato più chiaro. ;-)
 :ciao:

[leo72]

Sì, è vero.
Ho effettuato dei test ed ho notato che la funzione Shl non... funziona (scusate il gioco di parole).
Sembra che ci sia un bug per cui la funzione non valuta il tipo iniziale di dato (se byte, short, integer o long) e, conseguentemente, non calcola il bit sinistro più esterno.
Mi spiego...
Nel tuo esempio, 197 è rappresentato dal binario 11000101.
Shl(197,3) dà erroneamente 1576, che è rappresentato dal binario 11000101000.
Ora, se confrontiamo i 2 valori binari ci possiamo accorgere che in pratica il secondo è esattamente il primo con 3 zeri aggiunti a destra. La funzione ha cercato di spostare a sinistra i bit ma, non calcolando il margine esterno, ha ottenuto un valore costituito da 11 bit invece di ottenere 00101000 (40).
Lo stesso problema si ha con la funzione ROL, che dovrebbe ruotare i bit. Facendo ROL(197,3) si ottiene sempre erroneamente 1576 invece di 46 (00101110).
Segnalerò la cosa sulla mailing-list.

[leo72]

Segnalato.

[Picavbg]

leo72 ha scritto:
Sì, è vero.
Ho effettuato dei test ed ho notato che la funzione Shl non... funziona.

Scusa se insisto, ma il problema non è limitato solamenmte alle funzioni "Shl e Rol", bensì anche a "Ror" e "BTst", come avevo segnalato nella rispo n.4. Sempre con lo stesso numero ho preparato altri due allegati contenenti l'esito delle prove eseguite. :ciao:

[leo72]

BTst lavora correttamente: BTst(197,3) prova il bit in posizione 3, non il 3° bit (nei numeri binari, il 1° bit è identificato con la posizione 0, il 2° bit con la posizione 1, ecc... infatti i bit di 1 byte sono in posizione 0..7).
Ror, invece, sbaglia alla grande. Ho segnalato anche questo.

[Picavbg]

leo72 ha scritto:
BTst lavora correttamente: BTst(197,3).

Si, é vero, infatti non mi ero accorto che avevo commesso io un errore nel copiare le istruzioni. Ora ho riprovato ed  ho ottenuto un esito accettabile. Però ho visto anche che se il bit testato  è spento(0), il campo che riceve il risultato del test è giusto, cioè "0", mentre se il bit testato è acceso (1), il campo che riceve il risultato del test, stranamente, contiene un valotre negativo, cioè "-1" e non "1". Perché succede ciò? le istruzioni utilizzate sono le seguenti:

Codice: [Seleziona]

PRIVATE i AS Integer
.................
PUBLIC SUB TestBtn_Click()
  MioIntero = CInt(TextBox1.Text)  'converte la stringa digitata in un valore intero
  IF Int(MioIntero >= 0) AND (MioIntero < 256) THEN 
      result = CInt(TextBox2.Text) - 1
      i = BTst(MioIntero, result) 'esegue il test sul bit indicatto in result
      TextLabel7.Text = "BTst(" & MioIntero & "," & result & ")=" & i
      TextLabel9.Text = Str$(i)   'restituisce il bit esaminato
  ENDIF
End

Ciao.

[leo72]

BTst restituisce True o False. Non puoi usare il suo risultato come fosse un numero.

[leo72]

P.S.:
abbiamo fatto una figura barbina sulla mailing-list...
Benoit mi ha risposto... La funzione agisce correttamente, solo che non determina da sola il tipo di dato passato per cui se vogliamo avere lo spostamento bit per bit su un valore di tipo Byte dobbiamo specificarglielo esplicitamente con

Codice: [Seleziona]

SHL(CByte(197),3)

Il risultato è (correttamente) 40.

[md9327]

Figura barbina non direi, al massimo conferma l'assenza di una specifica più approfondita nella doc...

Riguardo alle funzioni sui bit, queste non sono compatibili a quelle usate in altri linguaggi, anche se Gambas è costruito su base C++. Il significato dei parametri, e la logica usata, sono indicati più per un uso non professionale, cosa alquanto usata da quando i linguaggi si sono evoluti in qualcosa non strettamente legato alla macchina su cui girano. Quello che voglio dire, è che queste funzioni sono più una costrizione, ovvero un'appendice storica, di cui ormai se ne fà poco uso, dati gli enormi mezzi che abbiamo oggi a disposizione (memoria, memoria e ancora memoria, a iosa...).
Le funzionalità in questione, sono la base della programmazione, ancora oggi è vero, però legate a logiche di basso livello (assembler, C, ecc.), che sono ora soppiantate dall'utilizzo moderno di oggetti e funzioni più orientate alle macro istruzioni; per fare un esempio, l'usilizzo di carratteri piuttosto che di bit, per indicare una determinata cosa, e via dicendo.
Anche se a me non piace molto lo spreco inutile di risorse, devo constatare che ora l'orientamento è quello di trascurare l'aspetto risorsa, a favore di una più facilitata gestione di un'applicazione. Già l'uso di linguaggi ad alto livello, slegati dall'hardware, e interpretati, sono un enorme spreco di risorse a cui, al giorno d'oggi, nessuno fà più caso (un hd da 1Tera costa 50/60euri...). A seguito di questo, e sperimentazione a parte, il voler introdurre nuovamente logiche usate più di 15/20 anni fà, penso sia ormai controproducente.

Questo, ovviamente, escludendo lo studio e la pura sperimentazione...

[leo72]

L'unica cosa per cui ormai si adoperano le funzioni sui bit sono gli algoritmi crittografici che, a causa della loro struttura, operano a livello di singoli bit di informazione. Per il resto concordo con te: sono ormai funzioni desuete e che non servono quasi più a nulla.