public static void Main(string[] args)
{
var array = new BitArray64(3);
Console.WriteLine(array[1]);
Console.WriteLine(string.Join(string.Empty, array));
}
static void Main(string[] args)
{
BitArray64 arr = new BitArray64(5);
arr.Add(18446744073709551615);
arr.Add(204203);
arr.Add(30494202);
arr.Add(40494202);
arr.Add(50494202);
foreach (var item in arr)
{
Console.WriteLine(item);
}
BitArray64 arr2 = new BitArray64(5);
arr2.Add(20494202);
arr2.Add(204203);
arr2.Add(30494202);
arr2.Add(40494202);
arr2.Add(50494202);
Console.WriteLine(arr.Equals(arr2));
Console.WriteLine(arr.GetHashCode());
arr2[0] = 1;
Console.WriteLine("Check for equality: {0}", arr == arr2);
}
static void Main()
{
BitArray64 firstNumber = new BitArray64(478l);
BitArray64 secondNumber = new BitArray64(479l);
Console.WriteLine("Bits of the number {0}", firstNumber.Number);
foreach (var bit in firstNumber)
{
Console.Write(bit + " ");
}
Console.WriteLine("Bits of the number {0}", secondNumber.Number);
foreach (var bit in secondNumber)
{
Console.Write(bit + " ");
}
Console.WriteLine();
Console.WriteLine("Bit from number {0} at position 0 is {1}", firstNumber.Number, firstNumber[0]);
Console.WriteLine();
Console.WriteLine("Bit from number {0} at position 0 is {1}", secondNumber.Number, secondNumber[0]);
Console.WriteLine("Hash code of {0} is {1}", firstNumber.Number, firstNumber.GetHashCode());
Console.WriteLine("Is {0} == {1} -> {2}", firstNumber.Number, secondNumber.Number, firstNumber == secondNumber);
Console.WriteLine("Is {0} != {1} -> {2}", firstNumber.Number, secondNumber.Number, firstNumber != secondNumber);
Console.WriteLine("Is {0} equals {1} -> {2}", firstNumber.Number, secondNumber.Number, firstNumber.Equals(secondNumber));
}
static void Main()
{
var number1 = new BitArray64(22L);
var number2 = new BitArray64(33L);
number2[62] = 1;
Console.WriteLine("number2[62] = {0}", number2[62]);
Console.WriteLine();
foreach (var bit in number1)
{
Console.Write(bit);
}
Console.WriteLine();
Console.WriteLine(number2);
Console.WriteLine();
Console.WriteLine(number1.GetHashCode());
Console.WriteLine(number2.GetHashCode());
Console.WriteLine();
Console.WriteLine("number1 == number2 : {0}", number1 == number2);
Console.WriteLine("number1 != number2 : {0}", number1 != number2);
Console.WriteLine("number1.Equals(number1) : {0}", number1.Equals(number1));
Console.WriteLine("number1.Equals(number2) : {0}", number1.Equals(number2));
}
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");
}
public static void Main()
{
BitArray64 firstArr = new BitArray64(7);
Console.WriteLine("Numeric value of the bit array = {0}", firstArr.NumValue);
Console.WriteLine(" Indexer test: ");
Console.WriteLine("Bit at position 2 = {0}", firstArr[2]);
firstArr[3] = 1;
Console.WriteLine("Numeric value of the bit array after setting bit[3] to 1 = {0}",
firstArr.NumValue);
Console.Write(separator);
BitArray64 secondArr = new BitArray64(465889955545565);
BitArray64 thirdArr = new BitArray64(15);
Console.WriteLine(" Test Equals() and ==, != operators: ");
Console.WriteLine(firstArr.Equals(secondArr));
Console.WriteLine(firstArr == secondArr);
Console.WriteLine(firstArr.Equals(thirdArr));
Console.WriteLine(firstArr == thirdArr);
Console.Write(separator);
Console.WriteLine(" Testing enumerator on bit array with numeric value {0}: ", firstArr.NumValue);
foreach (var bit in firstArr)
{
Console.Write(bit + " ");
}
Console.WriteLine();
Console.Write(separator);
}
public static void TestImplementations()
{
BitArray64 firstArray = new BitArray64(65765756);
BitArray64 secondArray = new BitArray64(65765756);
BitArray64 thirdArray = new BitArray64(4534);
// Testing GetHashCode()
Console.WriteLine("Hash code: " + firstArray.GetHashCode());
Separator();
// Testing Equals()
Console.WriteLine("The first array is equal to the second? " + firstArray.Equals(secondArray));
Separator();
// Testing Indexer
Console.WriteLine("Second index of array: " + firstArray[2]);
Separator();
Console.WriteLine("FirstArray is different from secondArray?");
Console.WriteLine(firstArray != secondArray);
Separator();
Console.WriteLine("FirstArray is equal to thrirdArray?");
Console.WriteLine(firstArray == thirdArray);
}
static void Main(string[] args)
{
// Testing the BitArray64
// Testing the foreach
BitArray64 bitArray1 = new BitArray64(256);
foreach (var item in bitArray1)
{
Console.Write(item);
}
Console.WriteLine();
// Testing the Equals method
BitArray64 bitArray2 = new BitArray64(256);
Console.WriteLine(object.Equals(bitArray1, bitArray2)); // True
Console.WriteLine(bitArray1 == bitArray2); // True
Console.WriteLine(bitArray1 != bitArray2); // False
// Testing the [] operator
BitArray64 bitArray3 = new BitArray64(9); // 1001 in binary
Console.WriteLine(bitArray3[0]); // 1
Console.WriteLine(bitArray3[1]); // 0
Console.WriteLine(bitArray3[2]); // 0
Console.WriteLine(bitArray3[3]); // 1
}
static void Main(string[] args)
{
BitArray64 simpleArray = new BitArray64();
foreach (var i in simpleArray)
{
Console.WriteLine(i + " ");
}
}
public override bool Equals(object obj)
{
BitArray64 other = obj as BitArray64;
if (other == null)
{
return(false);
}
return(this.Value == other.Value);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
BitArray64 objAsBitArray64 = obj as BitArray64;
return(this.bits == objAsBitArray64.bits);
}
public override bool Equals(object obj)
{
BitArray64 lala = (BitArray64)obj;
for (int i = 0; i < this.Length; i++)
{
if (this[i] != lala[i])
{
return(false);
}
}
return(true);
}
public override bool Equals(object obj)
{
BitArray64 value = obj as BitArray64;
if (value == null)
{
return(false);
}
if (this.Number != value.Number)
{
return(false);
}
return(true);
}
static void Main()
{
BitArray64 b = new BitArray64(8);
Console.WriteLine(b.Value); // 8
b[1] = 1;
Console.WriteLine(b.Value); // 10
b[3] = 0;
Console.WriteLine(b.Value); // 2
foreach (var bit in b)
{
Console.Write(bit);
}
Console.WriteLine();
}
public override bool Equals(object param)
{
BitArray64 bitArray = param as BitArray64;
if ((object)bitArray == null)
{
return(false);
}
if (!Object.Equals(this.number, bitArray.number))
{
return(false);
}
return(true);
}
public override bool Equals(object obj)
{
BitArray64 bitArray = obj as BitArray64;
if (bitArray == null)
{
return(false);
}
else if (bits == bitArray.bits)
{
return(true);
}
else
{
return(false);
}
}
public static void Main()
{
var firstTest = new BitArray64(ulong.MinValue);
var secondTest = new BitArray64(ulong.MaxValue);
var thirdTest = new BitArray64(ulong.MaxValue);
var forthTest = new BitArray64(100u);
Console.WriteLine("First 64 Bit array (ulong min value): " + firstTest);
Console.WriteLine("Second 64 Bit array (ulong max value): " + secondTest);
Console.WriteLine("Third 64 Bit array (ulong max value): " + thirdTest);
Console.WriteLine("Third 64 Bit array (100): " + forthTest);
Console.WriteLine("first == second: " + (firstTest == secondTest));
Console.WriteLine("first != second: " + (firstTest != secondTest));
Console.WriteLine("second != third: " + (secondTest == thirdTest));
Console.WriteLine(forthTest.Number);
Console.WriteLine(forthTest.GetHashCode());
}
static void Main(string[] args)
{
BitArray64 bit = new BitArray64(7);
Console.WriteLine(bit.number);
bit[0] = 0;
Console.WriteLine(bit.number);
bit[20] = 1;
Console.WriteLine(bit.number);
for (int i = 0; i < 64; i++)
{
Console.Write(bit[i]);
}
}
public override bool Equals(object obj)
{
if (!(obj is BitArray64))
{
return(false);
}
BitArray64 other = obj as BitArray64;
if (ReferenceEquals(other, null))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(this.Number == other.Number);
}
static void Main(string[] args)
{
BitArray64 number = new BitArray64(222l);
BitArray64 otherNumber = new BitArray64(2220l);
Console.WriteLine("Bits of the number {0}", number.Number);
foreach (var bit in number)
{
Console.Write(bit + " ");
}
Console.WriteLine();
Console.WriteLine("Bit at position 60 is {0}", number[60]);
Console.WriteLine("Hash code of {0} is {1}", number.Number, number.GetHashCode());
Console.WriteLine("number == otherNumber -> {0}", number == otherNumber);
Console.WriteLine("number != otherNumber -> {0}", number != otherNumber);
Console.WriteLine("number equals otherNumber -> {0}", number.Equals(otherNumber));
}
static void Main()
{
int numberInt = 69796;
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.WriteLine(Convert.ToString(numberInt, 2).PadLeft(64, '0'));
ulong numberUlong = 69796;
BitArray64 numBits = new BitArray64(numberUlong);
Console.ForegroundColor = ConsoleColor.Cyan;
foreach (var bit in numBits)
{
Console.Write(bit);
}
Console.WriteLine();
}
static void Main(string[] args)
{
BitArray64 bitArray1 = new BitArray64(2);
foreach (var bit in bitArray1)
{
Console.WriteLine(bit);
}
//Console.WriteLine();
//Console.WriteLine(bitArray1.GetHashCode());
BitArray64 bitArray2 = new BitArray64(5);
//Console.WriteLine(bitArray2.GetHashCode());
//Console.WriteLine();
Console.WriteLine("Are bitArray1 equal with bitArray2: {0}", bitArray1 == bitArray2);
}
public override bool Equals(object param)
{
if (!(param is BitArray64))
{
return(false);
}
BitArray64 bitArray = param as BitArray64;
if (bitArray.Number != this.Number)
{
return(false);
}
if (!object.Equals(bitArray.Number, this.InternalArray))
{
return(false);
}
return(true);
}
static void Main()
{
var test = new BitArray64(18);
var test1 = new BitArray64(18);
int extractedBit = test[59];
Console.WriteLine("Original input > test : {0}", test.BitValues);
Console.WriteLine("Original input > test1: {0}", test1.BitValues);
Console.WriteLine("test ? test1 >>> {0}", test.Equals(test1));
Console.WriteLine("GetHast test : {0}", test.GetHashCode());
Console.WriteLine("GetHast test1: {0}", test1.GetHashCode());
Console.WriteLine("Testing == and != operators");
Console.WriteLine(test == test1);
Console.WriteLine(test != test1);
Console.WriteLine("Changing bit at position 1 in test array to 1");
test[1] = 1;
Console.WriteLine(test.BitValues);
Console.WriteLine("Changing bit at position 1 back to 0");
test[1] = 0;
Console.WriteLine(test.BitValues);
}
public static bool operator ==(BitArray64 firstArray, BitArray64 secondArray)
{
return(BitArray64.Equals(firstArray, secondArray));
}
public static bool operator !=(BitArray64 bitArray1, BitArray64 bitArray2)
{
return(!(BitArray64.Equals(bitArray1, bitArray2)));
}
public static bool operator !=(BitArray64 firstNumber, BitArray64 secondNumber)
{
return(!BitArray64.Equals(firstNumber, secondNumber));
}
static void Main(string[] args)
{
var number2 = new BitArray64(1040);
Console.WriteLine(number2);
}
public static bool operator !=(BitArray64 first, BitArray64 second)
{
return(!BitArray64.Equals(first, second));
}
