public void TestYnosa()
{
Console.WriteLine("testing Ynosa");
var a1 = new EwahCompressedBitArray();
var a2 = new EwahCompressedBitArray();
a1.Set(5);
a1.Set(15);
a2.Set(5);
Assert.IsTrue(a1.Intersects(a2));
Console.WriteLine("testing Ynosa:ok");
}
public static void Main(string[] args)
{
var ewahBitmap1 = new EwahCompressedBitArray();
var ewahBitmap2 = new EwahCompressedBitArray();
ewahBitmap1.Set(0);
ewahBitmap1.Set(2);
ewahBitmap1.Set(64);
ewahBitmap1.Set(1 << 30);
Console.WriteLine("Running demo program:");
Console.WriteLine("bitmap 1:");
foreach (int k in ewahBitmap1)
Console.WriteLine(k);
ewahBitmap2.Set(1);
ewahBitmap2.Set(3);
ewahBitmap2.Set(64);
ewahBitmap2.Set(1 << 30);
Console.WriteLine("bitmap 2:");
foreach (int k in ewahBitmap2)
Console.WriteLine(k);
Console.WriteLine();
Console.WriteLine("bitmap 1 OR bitmap 2:");
EwahCompressedBitArray orbitmap = ewahBitmap1.Or(ewahBitmap2);
foreach (int k in orbitmap)
Console.WriteLine(k);
Console.WriteLine("memory usage: " + orbitmap.SizeInBytes + " bytes");
Console.WriteLine();
Console.WriteLine("bitmap 1 AND bitmap 2:");
EwahCompressedBitArray andbitmap = ewahBitmap1.And(ewahBitmap2);
foreach (int k in andbitmap)
Console.WriteLine(k);
Console.WriteLine("memory usage: " + andbitmap.SizeInBytes + " bytes");
Console.WriteLine("bitmap 1 XOR bitmap 2:");
EwahCompressedBitArray xorbitmap = ewahBitmap1.Xor(ewahBitmap2);
foreach (int k in xorbitmap)
Console.WriteLine(k);
Console.WriteLine("memory usage: " + andbitmap.SizeInBytes + " bytes");
Console.WriteLine("End of demo.");
Console.WriteLine("");
var tr = new EwahCompressedBitArrayTest();
tr.TestNot();
tr.TestCardinality();
tr.TestEwahCompressedBitArray();
tr.TestExternalization();
tr.TestLargeEwahCompressedBitArray();
tr.TestMassiveAnd();
tr.TestMassiveAndNot();
tr.TestMassiveOr();
tr.TestMassiveXOR();
tr.HabermaasTest();
tr.VanSchaikTest();
}
public void TestIntersectOddNess()
{
Console.WriteLine("testing IntersectOddNess");
var a1 = new EwahCompressedBitArray();
var a2 = new EwahCompressedBitArray();
a1.Set(12);
a2.Set(0);
a2.Set(1);
a2.Set(4);
a2.Set(14);
Assert.IsFalse(a1.Intersects(a2));
Console.WriteLine("testing IntersectOddNess:ok");
}
public void testsetSizeInBits()
{
Console.WriteLine("testing setSizeInBits");
for (int k = 0; k < 4096; ++k)
{
EwahCompressedBitArray ewah = new EwahCompressedBitArray();
ewah.SizeInBits = k;
Assert.AreEqual(ewah.SizeInBits, k);
Assert.AreEqual(ewah.GetCardinality(), 0);
EwahCompressedBitArray ewah2 = new EwahCompressedBitArray();
ewah2.SetSizeInBits(k, false);
Assert.AreEqual(ewah2.SizeInBits, k);
Assert.AreEqual(ewah2.GetCardinality(), 0);
EwahCompressedBitArray ewah3 = new EwahCompressedBitArray();
for (int i = 0; i < k; ++i)
{
ewah3.Set(i);
}
Assert.AreEqual(ewah3.SizeInBits, k);
Assert.AreEqual(ewah3.GetCardinality(), k);
EwahCompressedBitArray ewah4 = new EwahCompressedBitArray();
ewah4.SetSizeInBits(k, true);
Assert.AreEqual(ewah4.SizeInBits, k);
Assert.AreEqual(ewah4.GetCardinality(), k);
}
}
public void EwahIteratorProblem()
{
Console.WriteLine("testing ArnonMoscona");
var bitmap = new EwahCompressedBitArray();
for (int i = 9434560; i <= 9435159; i++)
{
bitmap.Set(i);
}
List <int> v = bitmap.GetPositions();
int k = 0;
foreach (int ival in bitmap)
{
Assert.AreEqual(ival, v[k++]);
}
Assert.AreEqual(k, v.Count);
for (k = 2; k <= 1024; k *= 2)
{
int[] bitsToSet = CreateSortedIntArrayOfBitsToSet(k, 434455 + 5 * k);
var ewah = new EwahCompressedBitArray();
foreach (int i in bitsToSet)
{
ewah.Set(i);
}
assertEqualsPositions(bitsToSet, ewah.GetPositions());
}
}
public void TestCardinality()
{
Console.WriteLine("testing EWAH GetCardinality");
var bitmap = new EwahCompressedBitArray();
bitmap.Set(int.MaxValue);
// Console.format("Total Items %d\n", bitmap.GetCardinality());
Assert.AreEqual(bitmap.GetCardinality(), 1);
Console.WriteLine("testing EWAH GetCardinality:ok");
}
public void TestHasNextSafe()
{
Console.WriteLine("testing TestHasNextSafe");
EwahCompressedBitArray bitmap = new EwahCompressedBitArray();
bitmap.Set(0);
IEnumerator <int> it = ((IEnumerable <int>)bitmap).GetEnumerator();
Assert.AreEqual(it.MoveNext(), true);
Assert.AreEqual(0, it.Current);
}
public void TestCustomSerializationStrategy()
{
Console.WriteLine("testing Custom serialization strategy");
// Create a compressed bit array, and randomly assign up to 20,000 bits to it.
var bmp = new EwahCompressedBitArray();
var r = new Random();
for (int i = 0; i < 23000; i++)
{
if (r.NextDouble() < 0.5)
{
bmp.Set(i);
}
}
byte[] originalDeserialized = null;
byte[] newFormDeserialized = null;
EwahCompressedBitArray newFormReserialized = null;
EwahCompressedBitArray originalReserialized = null;
// First de-serialize+ re-serialize 'normally'
using (var ms = new MemoryStream()) {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, bmp);
originalDeserialized = ms.ToArray();
ms.Seek(0, SeekOrigin.Begin);
originalReserialized = (EwahCompressedBitArray)bf.Deserialize(ms);
}
// Now de-serialize + re-serialize with the new form.
using (var ms = new MemoryStream()) {
EwahCompressedBitArraySerializer bf = new EwahCompressedBitArraySerializer();
bf.Serialize(ms, bmp);
newFormDeserialized = ms.ToArray();
ms.Seek(0, SeekOrigin.Begin);
newFormReserialized = (EwahCompressedBitArray)bf.Deserialize(ms);
}
// Assert that the new form is more compact than the original form.
Assert.Less(newFormDeserialized.Length, originalDeserialized.Length);
// Compare the 'normal' de-serialized + re-serialized form, against the original.
Assert.AreEqual(bmp, originalReserialized);
// Compare the 'new form' de-serialized + re-serialized form, against the original.
Assert.AreEqual(bmp, newFormReserialized);
// Compare the 'normal' de-serialized + re-serialized form, against the newly de-serialized + re-serialized form.
Assert.AreEqual(newFormReserialized, originalReserialized);
Console.WriteLine("testing Custom serialization strategy:ok");
}
public void TestLargeEwahCompressedBitArray()
{
Console.WriteLine("testing EWAH over a large array");
var myarray1 = new EwahCompressedBitArray();
const int n = 11000000;
for (int i = 0; i < n; ++i)
{
myarray1.Set(i);
}
Assert.AreEqual(myarray1.SizeInBits, n);
Console.WriteLine("testing EWAH over a large array:ok");
}
public void HabermaasTest()
{
Console.WriteLine("testing habermaasTest");
var bitArrayaa = new BitArray(1000131);
var aa = new EwahCompressedBitArray();
int[] val = { 55400, 1000000, 1000128 };
foreach (int t in val)
{
aa.Set(t);
bitArrayaa.Set(t, true);
}
assertEquals(bitArrayaa, aa);
var bitArrayab = new BitArray(1000131);
var ab = new EwahCompressedBitArray();
for (int i = 4096; i < (4096 + 5); i++)
{
ab.Set(i);
bitArrayab.Set(i, true);
}
ab.Set(99000);
bitArrayab.Set(99000, true);
ab.Set(1000130);
bitArrayab.Set(1000130, true);
assertEquals(bitArrayab, ab);
EwahCompressedBitArray bb = aa.Or(ab);
EwahCompressedBitArray bbAnd = aa.And(ab);
var bitArraybb = (BitArray)bitArrayaa.Clone();
bitArraybb.Or(bitArrayab);
var bitArraybbAnd = (BitArray)bitArrayaa.Clone();
bitArraybbAnd.And(bitArrayab);
AreEqual(bbAnd, bitArraybbAnd);
AreEqual(bb, bitArraybb);
Console.WriteLine("testing habermaasTest:ok");
}
public void TestNot()
{
Console.WriteLine("testing not");
var bmp = new EwahCompressedBitArray();
for (int i = 0; i <= 184; i++)
{
bmp.Set(i);
}
Assert.AreEqual(185, bmp.GetCardinality());
bmp.Not();
Assert.AreEqual(0, bmp.GetCardinality());
Console.WriteLine("testing not:ok");
}
public void TestCustomSerializationStrategy()
{
Console.WriteLine("testing Custom serialization strategy");
// Create a compressed bit array, and randomly assign up to 20,000 bits to it.
var bmp = new EwahCompressedBitArray();
var r= new Random();
for (int i = 0; i < 23000; i++) {
if (r.NextDouble() < 0.5) {
bmp.Set(i);
}
}
byte[] originalDeserialized= null;
byte[] newFormDeserialized= null;
EwahCompressedBitArray newFormReserialized= null;
EwahCompressedBitArray originalReserialized= null;
// First de-serialize+ re-serialize 'normally'
using (var ms = new MemoryStream()) {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, bmp);
originalDeserialized = ms.ToArray();
ms.Seek(0, SeekOrigin.Begin);
originalReserialized = (EwahCompressedBitArray)bf.Deserialize(ms);
}
// Now de-serialize + re-serialize with the new form.
using (var ms = new MemoryStream()) {
EwahCompressedBitArraySerializer bf = new EwahCompressedBitArraySerializer();
bf.Serialize(ms, bmp);
newFormDeserialized = ms.ToArray();
ms.Seek(0, SeekOrigin.Begin);
newFormReserialized = (EwahCompressedBitArray)bf.Deserialize(ms);
}
// Assert that the new form is more compact than the original form.
Assert.Less(newFormDeserialized.Length, originalDeserialized.Length);
// Compare the 'normal' de-serialized + re-serialized form, against the original.
Assert.AreEqual(bmp, originalReserialized);
// Compare the 'new form' de-serialized + re-serialized form, against the original.
Assert.AreEqual(bmp, newFormReserialized);
// Compare the 'normal' de-serialized + re-serialized form, against the newly de-serialized + re-serialized form.
Assert.AreEqual(newFormReserialized, originalReserialized);
Console.WriteLine("testing Custom serialization strategy:ok");
}
public UniversalSubjectPosition2(SortedSet <long> allRITEIds)
{
CausesOfLoss = new HashSet <SymbolicValue>()
{
"EQ", "WS", "CS", "FL", "WT", "FR", "TR", "SH", "FF", "SL", "WI", "SU", "HA", "TO", "SW", "FZ", "IC", "SN", "WF", "TS"
};
ResolvedExposureTypes = new HashSet <int>(ExposureType.GetIndividualIntExposureTypes(ExposureType.EExposureType.Loss));
AllRITEIds = new EwahCompressedBitArray();
OffsetForAllRITEIds = allRITEIds.First();
foreach (long RITEId in allRITEIds)
{
AllRITEIds.Set((int)(RITEId - OffsetForAllRITEIds));
}
}
public void TestSetGet()
{
Console.WriteLine("testing EWAH Set/get");
var ewcb = new EwahCompressedBitArray();
int[] val = { 5, 4400, 44600, 55400, 1000000 };
for (int k = 0; k < val.Length; ++k)
{
ewcb.Set(val[k]);
}
List <int> result = ewcb.GetPositions();
AreEqual(val, result);
Console.WriteLine("testing EWAH Set/get:ok");
}
public void TayaraTest()
{
Console.WriteLine("Tayara test");
for (int offset = 64; offset < (1 << 30); offset *= 2)
{
EwahCompressedBitArray a = new EwahCompressedBitArray();
EwahCompressedBitArray b = new EwahCompressedBitArray();
for (int k = 0; k < 64; ++k)
{
a.Set(offset + k);
b.Set(offset + k);
}
Assert.AreEqual(a.And(b).Equals(a), true);
Assert.AreEqual(a.Or(b).Equals(a), true);
}
}
/**
* Pseudo-non-deterministic test inspired by S.J.vanSchaik.
* (Yes, non-deterministic tests are bad, but the test is actually deterministic.)
*/
/**
* Pseudo-non-deterministic test inspired by Federico Fissore.
*
* @param length the number of set bits in a bitmap
*/
private static void ShouldSetBits(int length)
{
Console.WriteLine("testing shouldSetBits " + length);
int[] bitsToSet = CreateSortedIntArrayOfBitsToSet(length, 434222);
var ewah = new EwahCompressedBitArray();
Console.WriteLine(" ... setting " + bitsToSet.Length + " values");
foreach (int i in bitsToSet)
{
ewah.Set(i);
}
Console.WriteLine(" ... verifying " + bitsToSet.Length + " values");
AreEqual(ewah, bitsToSet);
Console.WriteLine(" ... checking GetCardinality");
Assert.AreEqual(bitsToSet.Length, ewah.GetCardinality());
}
public void SsiYanKaiTest()
{
Console.WriteLine("testing SsiYanKaiTest");
EwahCompressedBitArray a = EwahCompressedBitArray.BitmapOf(39935, 39936, 39937, 39938, 39939, 39940, 39941, 39942, 39943, 39944, 39945, 39946, 39947, 39948, 39949, 39950, 39951, 39952, 39953, 39954, 39955, 39956, 39957, 39958, 39959, 39960, 39961, 39962, 39963, 39964, 39965, 39966, 39967, 39968, 39969, 39970, 39971, 39972, 39973, 39974, 39975, 39976, 39977, 39978, 39979, 39980, 39981, 39982, 39983, 39984, 39985, 39986, 39987, 39988, 39989, 39990, 39991, 39992, 39993, 39994, 39995, 39996, 39997, 39998, 39999, 40000, 40001, 40002, 40003, 40004, 40005, 40006, 40007, 40008, 40009, 40010, 40011, 40012, 40013, 40014, 40015, 40016, 40017, 40018, 40019, 40020, 40021, 40022, 40023, 40024, 40025, 40026, 40027, 40028, 40029, 40030, 40031, 40032, 40033, 40034, 40035, 40036, 40037, 40038, 40039, 40040, 40041, 40042, 40043, 40044, 40045, 40046, 40047, 40048, 40049, 40050, 40051, 40052, 40053, 40054, 40055, 40056, 40057, 40058, 40059, 40060, 40061, 40062, 40063, 40064, 40065, 40066, 40067, 40068, 40069, 40070, 40071, 40072, 40073, 40074, 40075, 40076, 40077, 40078, 40079, 40080, 40081, 40082, 40083, 40084, 40085, 40086, 40087, 40088, 40089, 40090, 40091, 40092, 40093, 40094, 40095, 40096, 40097, 40098, 40099, 40100);
EwahCompressedBitArray b = EwahCompressedBitArray.BitmapOf(39935, 39936, 39937, 39938, 39939, 39940, 39941, 39942, 39943, 39944, 39945, 39946, 39947, 39948, 39949, 39950, 39951, 39952, 39953, 39954, 39955, 39956, 39957, 39958, 39959, 39960, 39961, 39962, 39963, 39964, 39965, 39966, 39967, 39968, 39969, 39970, 39971, 39972, 39973, 39974, 39975, 39976, 39977, 39978, 39979, 39980, 39981, 39982, 39983, 39984, 39985, 39986, 39987, 39988, 39989, 39990, 39991, 39992, 39993, 39994, 39995, 39996, 39997, 39998, 39999, 270000);
HashSet <int> aPositions = new HashSet <int>(a.GetPositions());
int intersection = 0;
EwahCompressedBitArray inter = new EwahCompressedBitArray();
HashSet <int> bPositions = new HashSet <int>(b.GetPositions());
foreach (int integer in bPositions)
{
if (aPositions.Contains(integer))
{
inter.Set(integer);
++intersection;
}
}
EwahCompressedBitArray and2 = a.And(b);
List <int> l1 = inter.GetPositions();
List <int> l2 = and2.GetPositions();
var ok = true;
if (l1.Count != l2.Count)
{
Console.WriteLine("cardinality differs = " + l1.Count + " " + l2.Count);
ok = false;
}
for (int k = 0; k < l1.Count; ++k)
{
if (l1[k] != l2[k])
{
Console.WriteLine("differ at " + k + " = " + l1[k] + " " + l2[k]);
ok = false;
}
}
Assert.IsTrue(ok);
Assert.AreEqual(true, and2.Equals(inter));
Assert.AreEqual(inter.GetHashCode(), and2.GetHashCode());
Assert.AreEqual(intersection, and2.GetCardinality());
}
public void testDebugSetSizeInBitsTest()
{
Console.WriteLine("testing DebugSetSizeInBits");
EwahCompressedBitArray b = new EwahCompressedBitArray();
b.Set(4);
b.SetSizeInBits(6, true);
List <int> positions = b.GetPositions();
Assert.AreEqual(2, positions.Count);
Assert.AreEqual(4, positions[0]);
Assert.AreEqual(5, positions[1]);
IEnumerator <int> iterator = ((IEnumerable <int>)b).GetEnumerator();
Assert.AreEqual(true, iterator.MoveNext());
Assert.AreEqual(4, iterator.Current);
Assert.AreEqual(true, iterator.MoveNext());
Assert.AreEqual(5, iterator.Current);
Assert.AreEqual(false, iterator.MoveNext());
}
public void VanSchaikTest()
{
Console.WriteLine("testing vanSchaikTest (this takes some time)");
const int totalNumBits = 32768;
const double odds = 0.9;
var rand = new Random(323232323);
for (int t = 0; t < 100; t++)
{
int numBitsSet = 0;
var cBitMap = new EwahCompressedBitArray();
for (int i = 0; i < totalNumBits; i++)
{
if (rand.NextDouble() < odds)
{
cBitMap.Set(i);
numBitsSet++;
}
}
Assert.AreEqual(cBitMap.GetCardinality(), numBitsSet);
}
Console.WriteLine("testing vanSchaikTest:ok");
}
public void TestExternalization()
{
Console.WriteLine("testing EWAH externalization");
var ewcb = new EwahCompressedBitArray();
int[] val = { 5, 4400, 44600, 55400, 1000000 };
foreach (int t in val)
{
ewcb.Set(t);
}
var bos = new MemoryStream();
var bf = new BinaryFormatter();
bf.Serialize(bos, ewcb);
bos.Position = 0;
ewcb = (EwahCompressedBitArray)bf.Deserialize(bos);
List <int> result = ewcb.GetPositions();
AreEqual(val, result);
Console.WriteLine("testing EWAH externalization:ok");
}
public void TestCloneEwahCompressedBitArray()
{
Console.WriteLine("testing EWAH clone");
EwahCompressedBitArray a = new EwahCompressedBitArray();
a.Set(410018);
a.Set(410019);
a.Set(410020);
a.Set(410021);
a.Set(410022);
a.Set(410023);
EwahCompressedBitArray b = (EwahCompressedBitArray)a.Clone();
a.SetSizeInBits(487123, false);
b.SetSizeInBits(487123, false);
Assert.AreEqual(a, b);
}
public void TestEwahCompressedBitArray()
{
Console.WriteLine("testing EWAH (basic)");
const long zero = 0;
const long specialval = 1L | (1L << 4) | (1L << 63);
const long notzero = ~zero;
var myarray1 = new EwahCompressedBitArray
{
zero, zero, zero, specialval, specialval, notzero, zero
};
Assert.AreEqual(myarray1.GetPositions().Count, 6 + 64);
var myarray2 = new EwahCompressedBitArray();
myarray2.Add(zero);
myarray2.Add(specialval);
myarray2.Add(specialval);
myarray2.Add(notzero);
myarray2.Add(zero);
myarray2.Add(zero);
myarray2.Add(zero);
Assert.AreEqual(myarray2.GetPositions().Count, 6 + 64);
List <int> data1 = myarray1.GetPositions();
List <int> data2 = myarray2.GetPositions();
var logicalor = new List <int>();
{
var tmp = new HashSet <int>();
tmp.AddRange(data1);
tmp.AddRange(data2);
logicalor.AddRange(tmp);
}
logicalor.Sort();
var logicaland = new List <int>();
logicaland.AddRange(data1);
logicaland.Retain(data2);
logicaland.Sort();
EwahCompressedBitArray arrayand = myarray1.And(myarray2);
AreEqual(arrayand.GetPositions(), logicaland);
EwahCompressedBitArray arrayor = myarray1.Or(myarray2);
AreEqual(arrayor.GetPositions(), logicalor);
EwahCompressedBitArray arrayandbis = myarray2.And(myarray1);
AreEqual(arrayandbis.GetPositions(), logicaland);
EwahCompressedBitArray arrayorbis = myarray2.Or(myarray1);
AreEqual(arrayorbis.GetPositions(), logicalor);
var x = new EwahCompressedBitArray();
foreach (int i in myarray1.GetPositions())
{
x.Set(i);
}
AreEqual(x.GetPositions(), myarray1.GetPositions());
x = new EwahCompressedBitArray();
foreach (int i in myarray2.GetPositions())
{
x.Set(i);
}
AreEqual(x.GetPositions(), myarray2.GetPositions());
x = new EwahCompressedBitArray();
foreach (int pos in myarray1)
{
x.Set(pos);
}
AreEqual(x.GetPositions(), myarray1.GetPositions());
x = new EwahCompressedBitArray();
foreach (int pos in myarray2)
{
x.Set(pos);
}
AreEqual(x.GetPositions(), myarray2.GetPositions());
Console.WriteLine("testing EWAH (basic):ok");
}
public bool Set(int i)
{
return(_bitmap.Set(i));
}
/**
* a non-deterministic test proposed by Marc Polizzi.
*
* @param maxlength the maximum uncompressed size of the bitmap
*/
public static void PolizziTest(int maxlength)
{
Console.WriteLine("Polizzi test with max length = " + maxlength);
for (int k = 0; k < 10000; k += 77)
{
var rnd = new Random();
var ewahBitmap1 = new EwahCompressedBitArray();
var clrBitArray1 = new BitArray(10000);
var ewahBitmap2 = new EwahCompressedBitArray();
var clrBitArray2 = new BitArray(10000);
int len = rnd.Next(maxlength);
for (int pos = 0; pos < len; pos++)
{
// random *** number of bits set ***
if (rnd.Next(7) == 0)
{
// random *** increasing *** values
ewahBitmap1.Set(pos);
clrBitArray1.Set(pos, true);
}
if (rnd.Next(11) == 0)
{
// random *** increasing *** values
ewahBitmap2.Set(pos);
clrBitArray2.Set(pos, true);
}
}
assertEquals(clrBitArray1, ewahBitmap1);
assertEquals(clrBitArray2, ewahBitmap2);
// XOR
{
EwahCompressedBitArray xorEwahBitmap = ewahBitmap1.Xor(ewahBitmap2);
var xorclrBitArray = (BitArray)clrBitArray1.Clone();
xorclrBitArray.Xor(clrBitArray2);
assertEquals(xorclrBitArray, xorEwahBitmap);
}
// AND
{
EwahCompressedBitArray andEwahBitmap = ewahBitmap1.And(ewahBitmap2);
var andclrBitArray = (BitArray)clrBitArray1.Clone();
andclrBitArray.And(clrBitArray2);
assertEquals(andclrBitArray, andEwahBitmap);
}
// AND
{
EwahCompressedBitArray andEwahBitmap = ewahBitmap2.And(ewahBitmap1);
var andclrBitArray = (BitArray)clrBitArray1.Clone();
andclrBitArray.And(clrBitArray2);
assertEquals(andclrBitArray, andEwahBitmap);
}
// AND NOT
{
EwahCompressedBitArray andNotEwahBitmap = ewahBitmap1
.AndNot(ewahBitmap2);
var andNotclrBitArray = (BitArray)clrBitArray1.Clone();
andNotclrBitArray.AndNot(clrBitArray2);
assertEquals(andNotclrBitArray, andNotEwahBitmap);
}
// AND NOT
{
EwahCompressedBitArray andNotEwahBitmap = ewahBitmap2
.AndNot(ewahBitmap1);
var andNotclrBitArray = (BitArray)clrBitArray2.Clone();
andNotclrBitArray.AndNot(clrBitArray1);
assertEquals(andNotclrBitArray, andNotEwahBitmap);
}
// OR
{
EwahCompressedBitArray orEwahBitmap = ewahBitmap1.Or(ewahBitmap2);
var orclrBitArray = (BitArray)clrBitArray1.Clone();
orclrBitArray.Or(clrBitArray2);
assertEquals(orclrBitArray, orEwahBitmap);
}
// OR
{
EwahCompressedBitArray orEwahBitmap = ewahBitmap2.Or(ewahBitmap1);
var orclrBitArray = (BitArray)clrBitArray1.Clone();
orclrBitArray.Or(clrBitArray2);
assertEquals(orclrBitArray, orEwahBitmap);
}
}
}