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); } }
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()); }
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() { // 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"); }
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)); }