public static void Main()
{
BitArray64 firstArray = new BitArray64(1);
Console.WriteLine(firstArray);
Console.WriteLine(firstArray.GetHashCode());
// firstArray[1] = 2; throws 'ArgumentOutOfRangeException'
// firstArray[64] = 1; throws 'ArgumentOutOfRangeException'
firstArray[1] = 1;
Console.WriteLine(firstArray);
BitArray64 secondArray = new BitArray64(3);
Console.WriteLine(secondArray);
Console.WriteLine(secondArray.GetHashCode());
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray != secondArray);
secondArray[0] = 0;
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray == secondArray);
BitArray64 thirdArray = new BitArray64(9223372036854251519);
Console.WriteLine(thirdArray);
Console.WriteLine(thirdArray.GetHashCode());
}
static void Main()
{
BitArray64 firstArray = new BitArray64(ulong.MaxValue);
Console.WriteLine("Type ulong MaxValue as BitArray64:\n {0}", firstArray);
BitArray64 secondArray = new BitArray64(8);
Console.WriteLine("Type ulong number 8 as BitArray64:\n {0}", secondArray);
secondArray[3] = 0;
secondArray[4] = 1;
Console.WriteLine("After setting the fouth bit to 0 and the fifth bit to 1:\n {0}", secondArray);
Console.WriteLine();
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray == secondArray);
Console.WriteLine(firstArray != secondArray);
Console.WriteLine();
foreach (var bit in firstArray)
{
Console.Write(bit);
}
Console.WriteLine();
}
public static void Main()
{
BitArray64 firstArray = new BitArray64(150);
Console.WriteLine(firstArray);
Console.WriteLine();
BitArray64 secondArray = new BitArray64(150);
Console.WriteLine(secondArray);
// Check are they equal
Console.WriteLine("Are they equal: {0}\n", firstArray.Equals(secondArray));
// Change element
secondArray[50] = 1;
Console.WriteLine(firstArray);
Console.WriteLine();
Console.WriteLine(secondArray);
Console.WriteLine("Are they equal: {0}\n", firstArray.Equals(secondArray));
// Get HashCode
Console.WriteLine("HashCode: {0}", firstArray.GetHashCode());
Console.WriteLine("HashCode: {0}", secondArray.GetHashCode());
}
static void Main()
{
try
{
BitArray64 bArr = new BitArray64(34);
BitArray64 bArrTwo = new BitArray64(34);
foreach (int b in bArr) Console.Write(b);
Console.WriteLine();
Console.WriteLine("Hash code: {0}", bArr.GetHashCode());
bArr[5] = 0;
foreach (byte b in bArr) Console.Write(b);
Console.WriteLine();
Console.WriteLine("Hash code now: {0}", bArr.GetHashCode());
bArr[5] = 1; // bArr = 34 again
Console.WriteLine("bArr == bArrTwo : {0}", (bArr == bArrTwo));
Console.WriteLine("bArr != bArrTwo : {0}", (bArr != bArrTwo));
Console.WriteLine("bArr equals bArrTwo : {0}", bArr.Equals(bArrTwo));
bArrTwo[24] = 1;
Console.WriteLine("bArr equals bArrTwo : {0}", bArr.Equals(bArrTwo));
}
catch (IndexOutOfRangeException e)
{
Console.WriteLine(e.Message);
}
}
public static void Main()
{
BitArray64 firstArray = new BitArray64(150);
Console.WriteLine(firstArray);
Console.WriteLine();
BitArray64 secondArray = new BitArray64(150);
Console.WriteLine(secondArray);
// Check are they equal
Console.WriteLine("Are they equal: {0}\n", firstArray.Equals(secondArray));
// Change element
secondArray[50] = 1;
Console.WriteLine(firstArray);
Console.WriteLine();
Console.WriteLine(secondArray);
Console.WriteLine("Are they equal: {0}\n", firstArray.Equals(secondArray));
// Get HashCode
Console.WriteLine("HashCode: {0}", firstArray.GetHashCode());
Console.WriteLine("HashCode: {0}", secondArray.GetHashCode());
}
static void Main()
{
BitArray64 number = new BitArray64(62);
foreach (var bit in number)
{
Console.Write(bit);
}
Console.WriteLine();
BitArray64 number2 = new BitArray64(100);
Console.WriteLine(number.Equals(number2));
Console.WriteLine(number[2]);
Console.WriteLine(number.GetHashCode());
number[14] = 1;
Console.WriteLine(number.Number);
foreach (var bit in number)
{
Console.Write(bit);
}
Console.WriteLine();
}
/// <summary>
/// Main entry point for Bit Array Testing.
/// </summary>
public static void Main()
{
BitArray64 num = new BitArray64(4);
Console.WriteLine("First:");
Console.WriteLine(num);
BitArray64 secondNum = new BitArray64(5);
Console.WriteLine("Second:");
Console.WriteLine(secondNum);
secondNum[0] = 0;
Console.WriteLine("Edited Second:");
Console.WriteLine(secondNum);
Console.Write("Fisrt equals second: ");
Console.WriteLine(num.Equals(secondNum));
Console.Write("Fisrt == second: ");
Console.WriteLine(num == secondNum);
Console.Write("Fisrt != second: ");
Console.WriteLine(num != secondNum);
// IEnumerable number = new BitArray64(2);
}
static void Main()
{
BitArray64 number = new BitArray64(43);
//check bits property
int[] bits = number.Bits;
for (int i = 0; i < bits.Length; i++)
{
Console.Write(bits[i]);
}
Console.WriteLine();
//test enumerator
foreach (var item in number)
{
Console.Write(item);
}
Console.WriteLine();
//check indexator
Console.WriteLine(number[0]);
Console.WriteLine(number[63]);
}
public static void Main()
{
var firstArray = new BitArray64(65478456456789);
Console.WriteLine("Binary representation: " + "\n" + firstArray.ToString());
Console.WriteLine("First bit = {0}", firstArray[0]);
Console.WriteLine("Last bit = {0}", firstArray[63]);
Console.WriteLine(firstArray[0] == firstArray[63]);
// enumerator
foreach (var bit in firstArray)
{
Console.Write(bit + " ");
}
Console.WriteLine();
// equality of two arrays
Console.WriteLine("Testing equality");
var secondArray = new BitArray64(65478456456789);
var thirdArrray = new BitArray64(65478456456788);
Console.WriteLine(firstArray.Equals(secondArray) == true ? "arrays have equal elements" : "arrays do not have equal elements");
Console.WriteLine(firstArray.Equals(thirdArrray) == true ? "arrays have equal elements" : "arrays do not have equal elements");
}
static void Main()
{
BitArray64 array1 = new BitArray64();
array1[3] = 1;
array1[7] = 1;
array1[9] = 1;
array1[11] = 1;
array1[12] = 1;
array1[13] = 1;
array1[42] = 1;
array1[28] = 1;
array1[39] = 1;
Console.WriteLine("This is the binary array 1:");
foreach (var bit in array1)
{
Console.Write(bit);
}
Console.WriteLine();
BitArray64 array2 = new BitArray64();
array2[3] = 1;
array2[7] = 1;
array2[9] = 1;
array2[11] = 1;
array2[12] = 1;
array2[13] = 1;
array2[42] = 1;
array2[28] = 1;
array2[39] = 1;
Console.WriteLine("This is the binary array 2:");
foreach (var bit in array2)
{
Console.Write(bit);
}
Console.WriteLine();
Console.WriteLine("arr1 == arr2: " + (array1 == array2));
Console.WriteLine("This is the binary array1 after changes:");
array1[12] = 0;
foreach (var bit in array1)
{
Console.Write(bit);
}
Console.WriteLine();
array1 = new BitArray64(4096);
Console.WriteLine("arr1 == arr2: " + (array1 == array2));
Console.WriteLine("arr1 != arr2: " + (array1 != array2));
Console.WriteLine("arr1 hash code: " + array1.GetHashCode());
}
static void Main()
{
BitArray64 firstArray = new BitArray64(ulong.MaxValue);
Console.WriteLine("Type ulong MaxValue as BitArray64:\n {0}", firstArray);
BitArray64 secondArray = new BitArray64(8);
Console.WriteLine("Type ulong number 8 as BitArray64:\n {0}", secondArray);
secondArray[3] = 0;
secondArray[4] = 1;
Console.WriteLine("After setting the fouth bit to 0 and the fifth bit to 1:\n {0}", secondArray);
Console.WriteLine();
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray == secondArray);
Console.WriteLine(firstArray != secondArray);
Console.WriteLine();
foreach (var bit in firstArray)
{
Console.Write(bit);
}
Console.WriteLine();
}
private static void TestBitArray64()
{
var sb = new StringBuilder();
var bitArray = new BitArray64(28);
sb.AppendLine("Number: 28");
sb.Append("Indexer: ");
for (int i = bitArray.Length - 1; i >= 0; i--)
{
sb.Append(bitArray[i]);
}
sb.Append("\nForeach: ");
Console.Write(sb);
sb.Clear();
foreach (var bit in bitArray)
{
sb.Insert(0, bit);
}
var anotherbitArray = new BitArray64(30);
sb.AppendLine()
.AppendLine("\nAnother number: 30")
.AppendFormat("Equals: {0}", bitArray.Equals(anotherbitArray))
.AppendLine()
.AppendFormat("== {0}", bitArray == anotherbitArray)
.AppendLine()
.AppendFormat("!= {0}", bitArray != anotherbitArray);
Console.WriteLine(sb);
}
static void Main()
{
BitArray64 number = new BitArray64(7);
foreach (var bit in number)
{
Console.Write(bit);
}
Console.WriteLine();
BitArray64 number2 = new BitArray64(7);
Console.WriteLine(number.Equals(number2));
Console.WriteLine(number[2]);
// print hash code
Console.WriteLine(number.GetHashCode());
// change bit
number[4] = 1;
// print the changed number and his bits
Console.WriteLine(number.Number);
foreach (var bit in number)
{
Console.Write(bit);
}
Console.WriteLine();
}
static void Main(string[] args)
{
BitArray64 myTestBitArray = new BitArray64(255);
foreach (var item in myTestBitArray)
{
Console.Write("{0} - ", item);
}
}
public override bool Equals(object obj)
{
BitArray64 temp = obj as BitArray64;
if (temp == null)
{
return(false);
}
return(this.Equals(temp));
}
static void Main()
{
var longNum = new BitArray64();
longNum[20] = 1;
longNum[4] = 1;
longNum[31] = 1;
longNum[55] = 1;
Console.WriteLine(longNum);
}
/* Define a class BitArray64 to hold 64 bit values inside an ulong value.
Implement IEnumerable<int> and Equals(…), GetHashCode(), [], == and !=.
*/
public static void Main()
{
var longNum = new BitArray64();
longNum[20] = 1;
longNum[4] = 1;
longNum[31] = 1;
longNum[55] = 1;
Console.WriteLine(longNum);
}
static void Main()
{
BitArray64 bitaArray = new BitArray64(100);
BitArray64 otherBitaArray = new BitArray64(100);
Console.WriteLine(string.Join("", bitaArray.BitArray));
Console.WriteLine(string.Join("", otherBitaArray.BitArray));
Console.WriteLine(bitaArray.Equals(otherBitaArray)); //False
Console.WriteLine(bitaArray.GetHashCode());
Console.WriteLine(otherBitaArray.GetHashCode());
}
public override bool Equals(object obj)
{
BitArray64 another = obj as BitArray64;
if (another == null)
{
return(false);
}
return(this.Number.Equals(another.Number));
}
static void Main()
{
BitArray64 arr1 = new BitArray64(873475629625);
BitArray64 arr2 = new BitArray64(8);
Console.WriteLine(arr1);
Console.WriteLine(arr2);
Console.WriteLine(arr2.GetHashCode());
Console.WriteLine(arr1 == arr2);
Console.WriteLine(arr1 != arr2);
}
//equals
public bool Equals(BitArray64 value)
{
if (ReferenceEquals(null, value))
{
return(false);
}
if (ReferenceEquals(this, value))
{
return(true);
}
return(this.number == value.number);
}
/// <summary>
/// Check if all the bits in the two BitArray64 variables match.
/// </summary>
/// <param name="obj">Object convetible to BitArray64</param>
/// <returns>True if all bits match, false if at least one bit does not match</returns>
public override bool Equals(object obj)
{
if (obj is BitArray64)
{
BitArray64 temp = obj as BitArray64;
if (this.arrayValueAsUlong == temp.arrayValueAsUlong)
{
return(true);
}
}
return(false);
}
private bool Equals(BitArray64 value)
{
if (ReferenceEquals(null, value))
{
return(false);
}
if (ReferenceEquals(this, value))
{
return(true);
}
return(this.container == value.container);
}
static void Main(string[] args)
{
ulong number = 12123154151234;
BitArray64 array = new BitArray64(number);
BitArray64 newArray = new BitArray64(81724);
Console.WriteLine(array.GetIndexValue(33));
Console.WriteLine(array == newArray);
Console.WriteLine(array.Equals(newArray));
Console.WriteLine(newArray.GetHashCode());
// This will throw an exception, because there are less than 33 bits in 81724:
// Console.WriteLine(newArray.GetIndexValue(33));
}
private static void Main(string[] args)
{
BitArray64 array = new BitArray64();
array[3] = 1;
array[9] = 1;
for (int i = 0; i < array.Length; i++)
{
Console.WriteLine("Bit {0} : {1}", i, array[i]);
}
Console.WriteLine(array);
}
public override bool Equals(object obj)
{
BitArray64 bitArray = obj as BitArray64;
if ((object)bitArray == null)
{
return(false);
}
if (object.Equals(this.number, bitArray.number))
{
return(true);
}
return(false);
}
static void Main()
{
BitArray64 firstNum = new BitArray64(9223372036854775808);
BitArray64 secondNum = new BitArray64(3);
if (firstNum != secondNum)
{
Console.WriteLine("The");
}
foreach (var item in secondNum)
{
Console.Write(item);
}
}
public override bool Equals(object obj)
{
BitArray64 arrToCompare = obj as BitArray64;
if (arrToCompare == null)
{
return(false);
}
if (arrToCompare.array != this.array)
{
return(false);
}
return(true);
}
static void Main()
{
BitArray64 bitArray = new BitArray64();
bitArray[63] = 1;
bitArray[62] = 1;
int index = 0;
foreach (int bit in bitArray)
{
Console.WriteLine("Bit {0,2}: {1}", index, bit);
index++;
}
Console.WriteLine(bitArray);
}
public override bool Equals(object obj)
{
BitArray64 bitarray = obj as BitArray64;
if (bitarray == null)
{
return(false);
}
for (int i = 0; i < this.BitArray.Length; i++)
{
if (this.BitArray[i] != bitarray[i])
{
return(false);
}
}
return(true);
}
public static void Main()
{
const ulong number = 8;
BitArray64 firstArray = new BitArray64(number);
BitArray64 secondArray = new BitArray64(number / 2);
Console.WriteLine(firstArray.ToString());
Console.WriteLine(secondArray.ToString());
Console.WriteLine(firstArray == secondArray);
firstArray[0] = 1;
firstArray[1] = 1;
Console.WriteLine(firstArray.ToString());
// Enumerator test
foreach (var bit in firstArray)
{
Console.Write(bit);
}
}
public static void Main()
{
BitArray64 someNumber = new BitArray64(5);
BitArray64 someOtherNumber = new BitArray64(7);
Console.WriteLine(someNumber);
Console.WriteLine(someOtherNumber);
Console.WriteLine(someNumber[0]);
Console.WriteLine(someNumber.GetHashCode());
Console.WriteLine(someOtherNumber.GetHashCode());
Console.WriteLine(someNumber.Equals(someNumber));
Console.WriteLine(someNumber.Equals(someOtherNumber));
Console.WriteLine(someNumber != someOtherNumber);
Console.WriteLine(someNumber == someOtherNumber);
}
public static void Main()
{
const ulong number = 8;
BitArray64 firstArray = new BitArray64(number);
BitArray64 secondArray = new BitArray64(number / 2);
Console.WriteLine(firstArray.ToString());
Console.WriteLine(secondArray.ToString());
Console.WriteLine(firstArray == secondArray);
firstArray[0] = 1;
firstArray[1] = 1;
Console.WriteLine(firstArray.ToString());
// Enumerator test
foreach (var bit in firstArray)
{
Console.Write(bit);
}
}
public static void Main()
{
// Creates two BitArray64s
var array1 = new BitArray64(number);
var array2 = new BitArray64(number / 2);
// Prints the arrays
Console.WriteLine("array1: {0}", string.Join(null, array1));
Console.WriteLine("array2: {0}", string.Join(null, array2));
// Compares the both arrays
Console.WriteLine("\n{0,-24} → {1}", "array1.Equals(array2)", array1.Equals(array2));
Console.WriteLine("{0,-24} → {1}\n", "array1 != array2", array1 != array2);
// Tests ToString() method
Console.WriteLine(array1);
// Tests the indexer
Console.WriteLine("array1[7] = {0}", array1[7]);
}
static void Main()
{
Console.WriteLine("Check for the enumerator:");
BitArray64 num = new BitArray64(24);
foreach (var i in num)
{
Console.WriteLine(i);
}
BitArray64 num2 = new BitArray64(22);
Console.WriteLine("{0} {1}",num,num2);
Console.WriteLine("Equals overriden:");
Console.WriteLine(num.Equals(num2));
Console.WriteLine("== overriden");
Console.WriteLine(num==num2);
Console.WriteLine("!= overriden");
Console.WriteLine(num == num2);
Console.WriteLine("Check for the index");
Console.WriteLine("{0}", num[3]);
Console.WriteLine(num.GetHashCode());
}
static void Main()
{
Console.WriteLine("Check for the enumerator:");
BitArray64 num = new BitArray64(24);
foreach (var i in num)
{
Console.WriteLine(i);
}
BitArray64 num2 = new BitArray64(22);
Console.WriteLine("{0} {1}", num, num2);
Console.WriteLine("Equals overriden:");
Console.WriteLine(num.Equals(num2));
Console.WriteLine("== overriden");
Console.WriteLine(num == num2);
Console.WriteLine("!= overriden");
Console.WriteLine(num == num2);
Console.WriteLine("Check for the index");
Console.WriteLine("{0}", num[3]);
Console.WriteLine(num.GetHashCode());
}
private static void Main()
{
var bitArr = new BitArray64(12436744071709501615);
var bitArr2 = new BitArray64(AllOnes);
byte line = new byte();
foreach (var bit in bitArr)
{
Console.Write("bit {0,2} : ", line++);
Console.WriteLine(bit);
}
Console.WriteLine("Hash codes:");
Console.WriteLine(bitArr.GetHashCode());
Console.WriteLine(bitArr2.GetHashCode());
Console.WriteLine(bitArr[32]);
bitArr[32] = 0;
Console.WriteLine(bitArr[32]);
bitArr[32] = 1;
Console.WriteLine(bitArr[32]);
Console.WriteLine(bitArr == bitArr2);
}
static void Main()
{
var firstBitArray = new BitArray64();
firstBitArray[0] = 1;
firstBitArray[1] = 1;
firstBitArray[2] = 0;
firstBitArray[3] = 1;
firstBitArray[1] = 0;
var secondBitArray = new BitArray64();
secondBitArray[0] = 1;
secondBitArray[1] = 1;
secondBitArray[2] = 0;
secondBitArray[3] = 1;
secondBitArray[63] = 1;
Console.WriteLine("First BitArray: \n" + firstBitArray);
Console.WriteLine("Second BitArray: \n" + secondBitArray);
bool equalCheck = firstBitArray == secondBitArray;
Console.WriteLine("\nEqual Check: " + equalCheck);
Console.WriteLine("First BitArray HashCode: " + firstBitArray.GetHashCode());
Console.WriteLine("Second BitArray HashCode: " + secondBitArray.GetHashCode());
Console.WriteLine(new string('-', 35));
Console.WriteLine("Second BitArray Foreach Test:");
foreach (var bit in secondBitArray)
{
Console.Write(bit);
}
Console.WriteLine();
Console.ReadKey();
}
static void Main()
{
var firstArr = new BitArray64(3462674);
Console.WriteLine("Bin: {0}", firstArr);
Console.WriteLine("First bit = {0}, Tenth = {1}, Twentieth = {2}, Thirtieth = {3}, Fortieth = {4}, Fiftieth = {5}, Sixtieth = {6}, Last = {7}", firstArr[0], firstArr[9], firstArr[19], firstArr[29], firstArr[39], firstArr[49], firstArr[59], firstArr[63]);
Console.WriteLine(firstArr[0] == firstArr[63]);
//enum
foreach (var bit in firstArr)
{
Console.Write(bit + " ");
}
Console.WriteLine();
//equal
var secondArr = new BitArray64(3462674);
var thirdArr = new BitArray64(231513521);
Console.WriteLine(firstArr.Equals(secondArr) == true ? "true" : "false");
Console.WriteLine(firstArr.Equals(thirdArr) == true ? "true" : "false");
}
private static void Main()
{
var bitArr = new BitArray64(12436744071709501615);
var bitArr2 = new BitArray64(AllOnes);
byte line = new byte();
foreach (var bit in bitArr)
{
Console.Write("bit {0,2} : ", line++);
Console.WriteLine(bit);
}
Console.WriteLine("Hash codes:");
Console.WriteLine(bitArr.GetHashCode());
Console.WriteLine(bitArr2.GetHashCode());
Console.WriteLine(bitArr[32]);
bitArr[32] = 0;
Console.WriteLine(bitArr[32]);
bitArr[32] = 1;
Console.WriteLine(bitArr[32]);
Console.WriteLine(bitArr == bitArr2);
}
public static void Main()
{
BitArray64 firstArray = new BitArray64(1);
Console.WriteLine(firstArray);
Console.WriteLine(firstArray.GetHashCode());
firstArray[1] = 1;
Console.WriteLine(firstArray);
BitArray64 secondArray = new BitArray64(3);
Console.WriteLine(secondArray);
Console.WriteLine(secondArray.GetHashCode());
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray != secondArray);
secondArray[0] = 0;
Console.WriteLine(firstArray.Equals(secondArray));
Console.WriteLine(firstArray == secondArray);
BitArray64 thirdArray = new BitArray64(883388883);
Console.WriteLine(thirdArray);
Console.WriteLine(thirdArray.GetHashCode());
}
static void Main(string[] args)
{
#region test1
BitArray64 bitObj = new BitArray64(31012365);
BitArray64 bitObj2 = new BitArray64(311);
BitArray64 bitObj3 = bitObj;
foreach (var item in bitObj)
{
Console.WriteLine(item);
}
Console.WriteLine("31012365 Equals 311: " + bitObj.Equals(bitObj2));
Console.WriteLine("HashCode: " + bitObj.GetHashCode());
Console.WriteLine("Bit[13] is: " + bitObj[13]);
Console.WriteLine("Original number is: " + bitObj.Number);
bitObj[13] = 0;
Console.WriteLine("Number after setting bit[13] to 0 is: " + bitObj.Number);
Console.WriteLine(bitObj==bitObj2);
Console.WriteLine(bitObj == bitObj3);
Console.WriteLine(bitObj.GetHashCode().Equals(bitObj3.GetHashCode()));
#endregion
}
//== operator
public static bool operator ==(BitArray64 first, BitArray64 second)
{
return(BitArray64.Equals(first, second));
}
public static bool operator !=(BitArray64 firstNumber, BitArray64 secondNumber)
{
return(BitArray64.Equals(firstNumber, secondNumber));
}
public static bool operator !=(BitArray64 arr1, BitArray64 arr2)
{
return(!(BitArray64.Equals(arr1, arr2)));
}
public static bool operator !=(BitArray64 firstBitArray, BitArray64 secondBitArray)
{
return(!BitArray64.Equals(firstBitArray, secondBitArray));
}
