c# - maj gauche l'ensemble d'un tableau d'octets

Oui, vous le pouvez. Consultez les méthodes suivantes, j'ai écrit:

///<summary>
///Rotates the bits in an array of bytes to the left.
///</summary>
///<param name="bytes">The byte array to rotate.</param>
public static void RotateLeft(byte[] bytes)
{
bool carryFlag = ShiftLeft(bytes);
if (carryFlag == true)
{
bytes[bytes.Length - 1] = (byte)(bytes[bytes.Length - 1] | 0x01);
}
}
///<summary>
///Rotates the bits in an array of bytes to the right.
///</summary>
///<param name="bytes">The byte array to rotate.</param>
public static void RotateRight(byte[] bytes)
{
bool carryFlag = ShiftRight(bytes);
if (carryFlag == true)
{
bytes[0] = (byte)(bytes[0] | 0x80);
}
}
///<summary>
///Shifts the bits in an array of bytes to the left.
///</summary>
///<param name="bytes">The byte array to shift.</param>
public static bool ShiftLeft(byte[] bytes)
{
bool leftMostCarryFlag = false;
//Iterate through the elements of the array from left to right.
for (int index = 0; index < bytes.Length; index++)
{
//If the leftmost bit of the current byte is 1 then we have a carry.
bool carryFlag = (bytes[index] & 0x80) > 0;
if (index > 0)
{
if (carryFlag == true)
{
//Apply the carry to the rightmost bit of the current bytes neighbor to the left.
bytes[index - 1] = (byte)(bytes[index - 1] | 0x01);
}
}
else
{
leftMostCarryFlag = carryFlag;
}
bytes[index] = (byte)(bytes[index] << 1);
}
return leftMostCarryFlag;
}
///<summary>
///Shifts the bits in an array of bytes to the right.
///</summary>
///<param name="bytes">The byte array to shift.</param>
public static bool ShiftRight(byte[] bytes) 
{
bool rightMostCarryFlag = false;
int rightEnd = bytes.Length - 1;
//Iterate through the elements of the array right to left.
for (int index = rightEnd; index >= 0; index--)
{
//If the rightmost bit of the current byte is 1 then we have a carry.
bool carryFlag = (bytes[index] & 0x01) > 0;
if (index < rightEnd)
{
if (carryFlag == true)
{
//Apply the carry to the leftmost bit of the current bytes neighbor to the right.
bytes[index + 1] = (byte)(bytes[index + 1] | 0x80);
}
}
else
{
rightMostCarryFlag = carryFlag;
}
bytes[index] = (byte)(bytes[index] >> 1);
}
return rightMostCarryFlag;
} 

Il semble que vous effectuez des opérations sur les bits sur la grande quantité de bits de les stocker dans un tableau d'octets. Pensez à utiliser BitArray classe et BitVector32 Structure. En fonction de ce que vous faites avec des morceaux vous pouvez créer une classe de ce genre. Notez que le changement fonctionne en O(1) au lieu de O(n).

public class BitRing : IEnumerable<bool>
{
private readonly BitArray m_InnerBitArray;
private int m_StarIndex;
public BitRing(byte[] bytes)
{
m_InnerBitArray = new BitArray(bytes);
m_StarIndex = 0;
}
public void ShiftLeft()
{
m_StarIndex++;
}
public void ShiftRight()
{
m_StarIndex--;
}
public bool this[int i]
{
get
{
int index = GetIndex(i);
return m_InnerBitArray[index];
}
set
{
int index = GetIndex(i);
m_InnerBitArray[index] = value;
}
}
private int GetIndex(int i)
{
return i - m_StarIndex%m_InnerBitArray.Count;
}
public IEnumerator<bool> GetEnumerator()
{
for (int i = m_StarIndex; i < m_InnerBitArray.Count; i++)
{
yield return m_InnerBitArray[i];
}
for (int i = 0; i < m_StarIndex; i++)
{
yield return m_InnerBitArray[i];
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}

Je ne pense pas qu'il y a un moyen intégré. J'ai mis en place l'opération de déplacement à gauche de vous décrit ci-dessous (en supposant que little endian). Ce n'est pas tout à fait aussi élégant que vous pouvez faire avec x86 assemblée (maj à effectuer des instructions), mais assez proche de ce que vous pourriez faire avec C.

Alternativement, vous pouvez l'utiliser presque la BigInteger struct (.NET 4 et ci-dessus) qui a un constructeur qui prend un tableau d'octets et un ToByteArray méthode. Mais son virage à gauche de l'opération de connexion s'étend l'octet de poids fort et de son décalage à droite de l'opération tronque. Donc, vous auriez besoin de compenser à la fois pour obtenir le comportement exact que vous avez décrit.

    //Left-shifts a byte array in place. Assumes little-endian. Throws on overflow.
static public void ShiftByteArrayLeft(byte[] array)
{
if (array == null)
throw new ArgumentNullException("array");
if (array[array.Length - 1] >= 0x80)
throw new OverflowException();
//move left-to-right, left-shifting each byte
for (int i = array.Length - 1; i >= 1; --i)
{
//left-shift current byte
array[i] <<= 1;
//carry the bit from the next/right byte if needed
if (array[i - 1] >= 0x80)
++array[i];
}
//finally shift the left-shift the right-most byte
array[0] <<= 1;
}
//Left-shifts a byte array in place. Assumes little-endian. Grows array as needed.
static public void ShiftByteArrayLeftAutoGrow(ref byte[] array)
{
if (array == null)
throw new ArgumentNullException("array");
if (array[array.Length - 1] >= 0x80)
{
//allocate a bigger array and do the left-shift on it
byte[] oldArray = array;
array = new byte[oldArray.Length + 1];
Array.Copy(oldArray, 0, array, 0, oldArray.Length);
}
ShiftByteArrayLeft(array);
}

Shift gauche:

for (int i = byteArray.Length - 1; i >= 0; i--) byteArray[i] = (byte)((byteArray[i] << 1) | ((i == 0) ? 0 : byteArray[i - 1] >> 7));

Décalage à droite:

for (int i = 0; i <= byteArray.Length - 1; i++) byteArray[i] = (byte)((byteArray[i] >> 1) | ((i == byteArray.Length - 1) ? 0 : byteArray[i + 1] << 7));