Laden...

Klasse zum Vertauschen/Drehen von Bits (zB: 10110110 --> 01101101)

Erstellt von TiltonJH vor 14 Jahren Letzter Beitrag vor 14 Jahren 4.373 Views
TiltonJH Themenstarter:in
87 Beiträge seit 2006
vor 14 Jahren
Klasse zum Vertauschen/Drehen von Bits (zB: 10110110 --> 01101101)

Beschreibung:

Diese Singelton Klasse vertauscht Bits, so wird zB aus 10110110 --> 01101101. Das macht sie für verschiedene Datentypen, darunter byte, ushort, uint, ulong oder byte[]. Das Erweitern für andere Datentypen sollte nicht so schwer sein. Kann dann ja jeder selbst machen.

MfG

Tilton


using System;

namespace Tools.Binary
{
	/// <summary>
	/// Provides methodes to reverse bits.
	/// For example: 10110110 --&gt; 01101101.
	/// </summary>
	public  sealed class ReverseBits
	{
		/// <summary>
		/// Holds the current singelton for the Tools.Binary.ReverseBits class.
		/// </summary>
		public static readonly ReverseBits Instance = new ReverseBits();

		/// <summary>
		/// Initializes a new instance of the Tools.Binary.ReverseBits class.
		/// </summary>
		private ReverseBits()
		{ }

		/// <summary>
		/// Holds the look up table for the current Tools.Binary.ReverseBits class.
		/// </summary>
		private byte[] lookUpTable;

		/// <summary>
		/// Initializes the look up table if needed.
		/// </summary>
		public void InitLookUpTable()
		{
			this.InitLookUpTable(false);
		}
		/// <summary>
		/// Initializes the look up table.
		/// </summary>
		/// <param name="force">
		/// If true it will force to create a new look up table, even if it already exists.
		/// If false it will only create a new look up table if needed.
		/// </param>
		public void InitLookUpTable(bool force)
		{
			if (this.lookUpTable == null || force)
			{
				this.lookUpTable = null;
				var newLookUpTable = new byte[byte.MaxValue + 1];
				for (int i = 0; i < byte.MaxValue + 1; i++)
				{
					newLookUpTable[byte.MaxValue - i] = this.Reverse((byte)i);
				}
				this.lookUpTable = newLookUpTable;
			}
		}

		/// <summary>
		/// Reverses the order of bits in one System.Byte.
		/// </summary>
		/// <param name="bits">The System.Byte to be reversed.</param>
		/// <returns>Returns the System.Byte with reversed bits.</returns>
		public byte Reverse(byte bits)
		{
			if (this.lookUpTable == null)
			{
				byte result = 0;
				for (int i = 0; i < 8; i++)
				{
					result <<= 1;
					result |= (byte)(bits & 1);
					bits >>= 1;
				}

				return result;
			}
			else
				return this.lookUpTable[bits];
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt16.
		/// </summary>
		/// <param name="bits">The System.UInt16 to be reversed.</param>
		/// <returns>Returns the System.UInt16 with reversed bits.</returns>
		public ushort Reverse(ushort bits)
		{
			return BitConverter.ToUInt16(this.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ushort result = 0;

			for (int i = 0; i < 16; i++)
			{
				result <<= 1;
				result |= (ushort)(bits & 1);
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt32.
		/// </summary>
		/// <param name="bits">The System.UInt32 to be reversed.</param>
		/// <returns>Returns the System.UInt32 with reversed bits.</returns>
		public uint Reverse(uint bits)
		{
			return BitConverter.ToUInt32(this.Reverse(BitConverter.GetBytes(bits)), 0);
	
			/*
			uint result = 0;

			for (int i = 0; i < 32; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt64.
		/// </summary>
		/// <param name="bits">The System.UInt64 to be reversed.</param>
		/// <returns>Returns the System.UInt64 with reversed bits.</returns>
		public ulong Reverse(ulong bits)
		{
			return BitConverter.ToUInt64(this.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ulong result = 0;

			for (int i = 0; i < 64; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in the System.Byte[].
		/// </summary>
		/// <param name="bits">The System.Byte[] to be reversed.</param>
		/// <returns>Returns the System.Byte[] with reversed bits.</returns>
		public byte[] Reverse(byte[] bytes)
		{
			if (bytes.Length > byte.MaxValue)
				this.InitLookUpTable();

			var reversedData = new byte[bytes.Length];
			for (int i = 0; i < bytes.Length; i++)
			{
				reversedData[bytes.Length - 1 - i] = this.Reverse(bytes[i]);
			}

			return reversedData;
		}
	}
}

Edit: noch eine bug beim force der look up table gefixed

Schlagwörter: bits, reverse, drehen, vertauschen

"In der Informatik geht es genauso wenig um Computer wie in der Astonomie um Teleskope."
Edsger W. Dijkstra

The Humble Programmer by Edsger W. Dijkstra

49.485 Beiträge seit 2005
vor 14 Jahren

Hallo TiltonJH,

wenn man eine Klasse mit solchen Hilfsfunktionen schreibt, was durchaus legitim ist, wird sie nicht objektorientierter, wenn man sie also Singleton schreibt, sondern man kann stattdessen guten Gewissens einen statische Klasse mit lauter statischen Methoden schreiben. Das macht die Benutzung dann sogar etwas komfortabler.

herbivore

TiltonJH Themenstarter:in
87 Beiträge seit 2006
vor 14 Jahren

Na das is ja mal lustig. 😁

Das übliche hin und her zwischen statisch und singelton. Ich kann mich da immer nicht recht entscheiden. Aber du hast hier sicher recht.

Das war ursprünglich auch eine statische Klasse. Hab die extra weil ich die hierreinstellen wollte nochmal mit Kommentaren ausgestattet und in eine Singelton gewandelt.

Für alle die sie doch ganz gern statisch hätten, hier noch mal meine statische Version.


using System;

namespace Tools.Binary
{
	/// <summary>
	/// Provides methodes to reverse bits.
	/// For example: 10110110 --&gt; 01101101.
	/// </summary>
	public static class ReverseBits
	{
		/// <summary>
		/// Holds the look up table for the Tools.Binary.ReverseBits class.
		/// </summary>
		private static byte[] lookUpTable;

		/// <summary>
		/// Initializes the look up table if needed.
		/// </summary>
		public static void InitLookUpTable()
		{
			ReverseBits.InitLookUpTable(false);
		}
		/// <summary>
		/// Initializes the look up table.
		/// </summary>
		/// <param name="force">
		/// If true it will force to create a new look up table, even if it already exists.
		/// If false it will only create a new look up table if needed.
		/// </param>
		public static void InitLookUpTable(bool force)
		{
			if (ReverseBits.lookUpTable == null || force)
			{
				ReverseBits.lookUpTable = null;
				var newLookUpTable = new byte[byte.MaxValue + 1];
				for (int i = 0; i < byte.MaxValue + 1; i++)
				{
					newLookUpTable[byte.MaxValue - i] = ReverseBits.Reverse((byte)i);
				}
				ReverseBits.lookUpTable = newLookUpTable;
			}
		}

		/// <summary>
		/// Reverses the order of bits in one System.Byte.
		/// </summary>
		/// <param name="bits">The System.Byte to be reversed.</param>
		/// <returns>Returns the System.Byte with reversed bits.</returns>
		public static byte Reverse(byte bits)
		{
			if (ReverseBits.lookUpTable == null)
			{
				byte result = 0;
				for (int i = 0; i < 8; i++)
				{
					result <<= 1;
					result |= (byte)(bits & 1);
					bits >>= 1;
				}

				return result;
			}
			else
				return ReverseBits.lookUpTable[bits];
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt16.
		/// </summary>
		/// <param name="bits">The System.UInt16 to be reversed.</param>
		/// <returns>Returns the System.UInt16 with reversed bits.</returns>
		public static ushort Reverse(ushort bits)
		{
			return BitConverter.ToUInt16(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ushort result = 0;

			for (int i = 0; i < 16; i++)
			{
				result <<= 1;
				result |= (ushort)(bits & 1);
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt32.
		/// </summary>
		/// <param name="bits">The System.UInt32 to be reversed.</param>
		/// <returns>Returns the System.UInt32 with reversed bits.</returns>
		public static uint Reverse(uint bits)
		{
			return BitConverter.ToUInt32(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);
	
			/*
			uint result = 0;

			for (int i = 0; i < 32; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt64.
		/// </summary>
		/// <param name="bits">The System.UInt64 to be reversed.</param>
		/// <returns>Returns the System.UInt64 with reversed bits.</returns>
		public static ulong Reverse(ulong bits)
		{
			return BitConverter.ToUInt64(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ulong result = 0;

			for (int i = 0; i < 64; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in the System.Byte[].
		/// </summary>
		/// <param name="bits">The System.Byte[] to be reversed.</param>
		/// <returns>Returns the System.Byte[] with reversed bits.</returns>
		public static byte[] Reverse(byte[] bytes)
		{
			if (bytes.Length > byte.MaxValue)
				ReverseBits.InitLookUpTable();

			var reversedData = new byte[bytes.Length];
			for (int i = 0; i < bytes.Length; i++)
			{
				reversedData[bytes.Length - 1 - i] = ReverseBits.Reverse(bytes[i]);
			}

			return reversedData;
		}
	}
}

Edit: noch eine bug beim force der look up table gefixed

"In der Informatik geht es genauso wenig um Computer wie in der Astonomie um Teleskope."
Edsger W. Dijkstra

The Humble Programmer by Edsger W. Dijkstra