Newsgroup: it.comp.lang.visual-basic
Titolo: [?] traduzione dal C

Per favore, chi mi traduce in VB l'espressione
a = b <<< c
e
a = b << c
Ciao

Zanna[work] ha scritto:

  questo sembra lo shit bit a bit che non ho mai usato, ma cosa sono a b
e c?

 a = b << c
a = b * 2^ c
Ciao.
--
BSD is for UNIX-lovers -- linux is for Windows-haters.

 Ciao
Ciao Zanna,
quando lavori con le operazioni bit a bit fai attenzione al tipo 
di dati, se integer, rischi l'overflow, e al segno dei numeri, 
rischi di perderlo, o peggio di settarlo negativo per promozione
fino al primo bit di sinistra bit.
Per le operazioni di cui necessiti prova ad usare, ed adattare,
queste 2 routines:
'Shift to Left (<<) di lNum per nShift Posizioni
Public Function LeftBitShift(ByVal lNum as Long, ByVal nShift as
Integer) as
long
   'Clear top bits
    lNum= lNum And (2 ^ (31 - nShift) - 1)
    'Shift the bits
    LeftBitShift= lNum* (2 ^ nShift)
End Function
'Shift to Right (>>) [Rotate] di lNum per nShift Posizioni
Public Function RightBitShift(ByVal lNum as Long, ByVal nShift as
Integer)
as long
    'Shift the bits
    RightBitShift= lNum \ (2 ^ nShift)
End Function
Se i tuoi dati non sono Long, dichiara un UDT appropriato e usa la 
funzione LSet, per il cui uso e scopo cfr. MSDN.
HTH
Ciao
	Adriano

 <<< non esiste. Dove l'hai trovato?
Trovato, basta leggere la documentazione :)
E' una funzione descritta per l'implementazione del MD5:
Let [abcd k s i] denote the operation
          a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s)
Let X <<< s denote the 32-bit value obtained by circularly
   shifting (rotating) X left by s bit positions. Let not(X) denote the
   bit-wise complement of X, and let X v Y denote the bit-wise OR of X
   and Y.
Un'altra serie incomprensibile č:
          F(X,Y,Z) = XY v not(X) Z
          G(X,Y,Z) = XZ v Y not(Z)
          H(X,Y,Z) = X xor Y xor Z
          I(X,Y,Z) = Y xor (X v not(Z))
   In each bit position F acts as a conditional: if X then Y else Z.
Ma come cavolo...
Ciao

>>>> "Z" == Zanna[work]  <Zanna> writes:
Z> Let X <<< s denote the 32-bit value obtained by circularly
Z>    shifting (rotating) X left by s bit positions.
    Dim i As Long
    Dim op As Long
 
    op = IIf(i & 80000000, 1, 0)
 
    i = ((i And &H7FFFFFFF) * 2) Or op
Z> Un'altra serie incomprensibile è:
Naaah, un'attimo di ragionamento. XY e` X and Y e se i valori sono parole
allora si opera in sequenza su ogni bit di ciascuna parola...
Z>           F(X,Y,Z) = XY v not(X) Z
Se X e` 0, allora XY va a zero e "passa" Not(X)Z in quanto Not(X) e` 1
Z>           G(X,Y,Z) = XZ v Y not(Z)
Stavolta Z guida la danza di X e Y (se Z=1)allora X, altrimenti Y
Z>           H(X,Y,Z) = X xor Y xor Z
xor vale 1 se i due operandi sono diversi, 0 se sono uguali.
Vale 1 se X vale 1 e Y e Z sono uguali oppure se X vale 0 e Y e Z son diversi.
Z>           I(X,Y,Z) = Y xor (X v not(Z))
Y viene invertito se X vale 1 o Z vale 0
-- 
Gian  | main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Uberto|                        David Korn, 1987 ioccc best one liner 
Lauri |-------------------------------------------------------------------
(aka saint) >>Vedere X-Nospam nell'header - See X-Nospam field in Header<<

           a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s)
Un momento...
Viene utilizzato come spiegazione (in un commento).
Perché l'operatore <<< in C non esiste, e non può quindi essere
utilizzato nel codice.
