public static void And_EmptyArray()
{
BitArray bitArray1 = new BitArray(0);
BitArray bitArray2 = new BitArray(0);
Assert.Equal(0, bitArray1.And(bitArray2).Length);
}
// BreakStmt
public override bool Walk(BreakStatement node)
{
BitArray exit = PeekLoop();
// break outside loop
exit?.And(_bits);
return(true);
}
public static void And_Operator(bool[] l, bool[] r, bool[] expected)
{
BitArray left = new BitArray(l);
BitArray right = new BitArray(r);
BitArray actual = left.And(right);
Assert.Same(left, actual);
Assert.Equal(actual.Length, expected.Length);
for (int i = 0; i < expected.Length; i++)
{
Assert.Equal(expected[i], actual[i]);
}
}
public void AddDependency(BitArray from, BitArray to)
{
if (from.Count != Keys.Count)
{
return;
}
if (to.Count != Keys.Count)
{
return;
}
to.And(Utils.Not(from));
var index =
DependencyList.FindIndex(tuple => tuple.Item1.EqualsTo(from));
if (index != -1)
{
DependencyList[index].Item2.Or(to);
}
else
{
DependencyList.Add(new Tuple <BitArray, BitArray>(from, to));
}
_prepared = false;
}
public GameUnit GetOffset(BitArray tileType)
{
BitArray leftTopTall = TileInfo.CreateTileType();
leftTopTall.Set((int)TileInfo.TileFlag.LeftSlope, true);
leftTopTall.Set((int)TileInfo.TileFlag.TopSlope, true);
leftTopTall.Set((int)TileInfo.TileFlag.TallSlope, true);
BitArray rightBottomShort = TileInfo.CreateTileType();
rightBottomShort.Set((int)TileInfo.TileFlag.RightSlope, true);
rightBottomShort.Set((int)TileInfo.TileFlag.BottomSlope, true);
rightBottomShort.Set((int)TileInfo.TileFlag.ShortSlope, true);
if ((leftTopTall.And(tileType).IsEqual(leftTopTall)) ||
(rightBottomShort.And(tileType).IsEqual(rightBottomShort)))
{
return(Units.TileToGame(1));
}
BitArray leftBottomTall = TileInfo.CreateTileType();
leftBottomTall.Set((int)TileInfo.TileFlag.LeftSlope, true);
leftBottomTall.Set((int)TileInfo.TileFlag.BottomSlope, true);
leftBottomTall.Set((int)TileInfo.TileFlag.TallSlope, true);
BitArray rightTopShort = TileInfo.CreateTileType();
rightTopShort.Set((int)TileInfo.TileFlag.RightSlope, true);
rightTopShort.Set((int)TileInfo.TileFlag.TopSlope, true);
rightTopShort.Set((int)TileInfo.TileFlag.ShortSlope, true);
if (leftBottomTall.And(tileType).IsEqual(leftBottomTall) ||
rightTopShort.And(tileType).IsEqual(rightTopShort))
{
return(0.0f);
}
return(Units.HalfTile);
}
public static void Test()
{
Console.WriteLine();
Console.WriteLine("Working With BitArray ");
Console.WriteLine("".PadLeft(40, '='));
BitArray arr = new BitArray(64);
arr = new BitArray(new[] { true, true, true, true }); // value of 15
arr = new BitArray(64); // length is 64 bit
arr = new BitArray(8, true); // value of 255 , with array length 8 bit
arr = new BitArray(new[] { 0x0F }); // Value of 15 one int in the array is with the length of 32 bit.
// convert to array of bool
List <bool> bools = arr.OfType <bool>().ToList();
Console.WriteLine(string.Join(", ", bools));
// convert to array of int , each integer represent bit
List <int> ints = arr.OfType <bool>().Select(b => b ? 1 : 0).ToList();
Console.WriteLine(string.Join("", ints));
var arrOr = arr.Or(new BitArray(new[] { 0x0F }));
var orResult = new int[1];
arrOr.CopyTo(orResult, 0);
Console.WriteLine($"{arrOr[0]:x2}");
var arrAnd = arr.And(new BitArray(new int[] { 0x0F }));
var andResult = new int[1];
arrAnd.CopyTo(orResult, 0);
Console.WriteLine($"{arrAnd[0]:x2}");
}
static void Zadanie()
{
int[] U = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// __1__
{
BitArray A = Bits_read(new int[] { 0, 2, 3, 4, 6, 7 }, U);
BitArray B = Bits_read(new int[] { 1, 2, 4, 5, 7, 8 }, U);
BitArray C = Bits_read(new int[] { 1, 3, 5, 7, 9 }, U);
BitArray Result = (B.Or(C)).Not();
Bits_write("1. ", Result, U);
}
{
BitArray B = Bits_read(new int[] { 4, 8 }, U);
BitArray C = Bits_read(new int[] { 1, 3, 5, 7, 9 }, U);
BitArray Result = B.And(C.Not());
Bits_write("2. ", Result, U);
}
{
BitArray A = Bits_read(new int[] { 1, 3, 6, 7, 9 }, U);
BitArray C = Bits_read(new int[] { 2, 4, 8 }, U);
BitArray Result = A.Or(C);
Bits_write("3. ", Result, U);
}
}
static void SpecialOp3(ref BitArray A, ref BitArray A1, ref BitArray C, ref BitArray C1, HashSet <string> U)
{
BitArray opAC = A.And(C);
BitArray notC = C.Not();
BitArray opAnotC = A1.And(notC);
BitArray notA = A1.Not();
BitArray opNotAC = notA.And(C);
BitArray opUnionAC = opAnotC.Or(opAC);
BitArray opUnionallAC = opUnionAC.Or(opNotAC);
BitArray total = opUnionAC.Not();
Console.Write("Задание №3: ");
for (int i = 0; i < U.Count; i++)
{
if (total[i] == true)
{
foreach (char el in U.ElementAt(i))
{
Console.Write(el + " ");
}
}
}
Console.WriteLine();
}
static void Main(string[] args)
{
BitArray arr1 = new BitArray(10);
BitArray arr2 = new BitArray(10, true);
bool[] arrBool = new bool[] { true, false, true, false, true };
BitArray arr3 = new BitArray(arrBool);
Console.Write("Array Bool value: ");
PrintBit(arr3, 5);
byte[] arrByte = new byte[] { 1, 2, 3, 4, 5 };
BitArray arr4 = new BitArray(arrByte);
Console.WriteLine("Array Byte length: {0} ", arr4.Length);
Console.Write("Array Byte value: ");
PrintBit(arr4, 8);
int[] arrInt = new int[] { 1, 2, 3, 4, 5 };
BitArray arr5 = new BitArray(arrInt);
Console.Write("Array Int value: ");
PrintBit(arr5, 32);
BitArray A = new BitArray(new bool[] { false, false, true, true });
BitArray B = new BitArray(new bool[] { false, true, false, true });
Console.WriteLine("Initial values");
Console.Write("A:");
PrintBit(A, 4);
Console.Write("B:");
PrintBit(B, 4);
Console.Write("Result AND: ");
PrintBit(A.And(B), 4);
}
static void Main(string[] args)
{
//Question 1
//ArrayList
Console.WriteLine("ArrayList");
ArrayList arraylist = new ArrayList();
//arraylist.Add(13);
//arraylist.Add(11);
arraylist.Add("Asia");
arraylist.Add("Ala");
foreach (var item in arraylist)
{
Console.WriteLine(item);
}
Console.WriteLine("Liczba elementów, które ArrayLista może zawierać: {0}", arraylist.Capacity);
Console.WriteLine("Liczba elementów: {0}", arraylist.Count);
arraylist.Sort(); //tylko gdzy mam obiekty tego samego rodzaju, bo mogę mieć różne ale różnych nie mogę sortować
foreach (var item in arraylist)
{
Console.WriteLine(item);
}
Console.WriteLine();
//Hashtable
Console.WriteLine("Hashtable");
Hashtable ht = new Hashtable();
ht.Add("001", "Audi");
ht.Add("002", "Pagani");
ht.Add("003", "Lamborghini");
ht.Add("004", "Nissan");
ht.Add("005", "Volvo");
ht.Add("006", null);
if (ht.ContainsKey("005")) //jeśli istnieje klucz 005
{
Console.WriteLine("Wartość klucza 005 : {0}", ht["005"]);
}
if (ht.ContainsValue("Volvo"))// Możemy sprawdzić czy w kolekcji jest konkretna wartość
{
Console.WriteLine("Volvo jest elementem kolekcji");
}
// Pobierzemy teraz wszystkie klucze
ICollection key = ht.Keys;
foreach (string k in key)
{
Console.WriteLine("Klucz: {0} || wartość: {1}", k, ht[k]);
}
ht.Clear(); //czyślimy całą zawartość
Console.WriteLine("Pozostała liczba elementów: {0}", ht.Count); //0 elementów
Console.WriteLine();
//SortedList
Console.WriteLine("SortedList ");
SortedList sl = new SortedList();
sl.Add("001", "Audi"); // Dodajemy pary: klucz/wartość
sl.Add("002", "Pagani");
sl.Add("005", "Volvo");
sl.Add("004", "Nissan"); // element ten zostaje dodany do listy przed pozycją 005
sl.Add("003", "Lamborghini"); // element ten zostaje dodany do listy przed powyższym elementem
// Dostęp przez klucz -> jak HashTable
if (sl.ContainsKey("004"))
{
Console.WriteLine("Wartość: {0}", sl["004"]);
}
// Dostęp przez wartość -> jak ArrayList
if (sl.ContainsValue("Nissan"))
{
Console.WriteLine("Nissan jest elementem kolekcji");
}
ICollection keys = sl.Keys;
foreach (string k in keys)
{
Console.WriteLine("Klucz: {0} || wartość: {1}", k, sl[k]);
}
Console.WriteLine();
//Stack
Console.WriteLine("Stack");
Stack st = new Stack();
st.Push("A");
st.Push("B");
st.Push("C");
st.Push("D");
// Nasz stos jest pełny. Zgodnie z definicją kolejny element powinien trafić na pierwszą pozycję
st.Push("TEST");
Console.WriteLine("Zawartość stosu: ");
foreach (var item in st)
{
Console.WriteLine(item);
}
// usuwamy 2 pozycje
st.Pop(); //usunie sie TEST
st.Pop(); //usunie sie D
// Możemy również zwrócić obiekt na szczycie stosu bez usuwania
Console.WriteLine("Pierwszy element: {0}", st.Peek()); //C
Console.WriteLine();
//Queue
Console.WriteLine("Queue");
Queue q = new Queue();
q.Enqueue("A");
q.Enqueue("B");
q.Enqueue("C");
q.Enqueue("D");
q.Dequeue(); //first-in, first-out. Pierwszy dodany el to pierwszy do usunięcia.Usuneliśmy A
Console.WriteLine("Zawartość kolejki: ");
foreach (var item in q)
{
Console.WriteLine(item);
}
// Spróbujmy jeszcze zobaczyć jaki element usuwamy
string tekst = (string)q.Dequeue();
Console.WriteLine("Usuneliśmy: {0}", tekst); //Usunelismy B
Console.WriteLine();
//BitArray
Console.WriteLine("BitArray");
// Tworzymy dwie tablice o rozmiarze 8 bitów
BitArray ba1 = new BitArray(8);
BitArray ba2 = new BitArray(8);
byte[] a = { 60 };
byte[] b = { 13 };
// zapisujemy wartości w naszych tablicach
ba1 = new BitArray(a);
ba2 = new BitArray(b);
// Zawartość pierwszej z nich
Console.WriteLine("Tablica bitów ba: 60");
for (int i = 0; i < ba1.Count; i++)
{
// Co oznacza poniższy zapis
// Na każdy wyraz poświęcamy 6 znaków
// Ale z wyrównianiem do lewej strony
// Gdybyśmy zapis zmienili na {0, 6}
// Wyrównanie byłoby do prawej strony
Console.Write("{0, -6}", ba1[i]);
}
Console.WriteLine();
// Zawartość drugiej z nich
Console.WriteLine("Tablica bitów ba: 13");
for (int i = 0; i < ba2.Count; i++)
{
Console.Write("{0, -6}", ba2[i]);
}
Console.WriteLine();
// Połączmy teraz obie tablie operatorem logicznym AND
BitArray ba3 = new BitArray(8);
ba3 = ba1.And(ba2);
Console.WriteLine("Tablica bitów ba3: ba1 i ba2");
for (int i = 0; i < ba3.Count; i++)
{
Console.Write("{0, -6}", ba3[i]);
}
// Wynik działania programu
// Tablica bitów ba: 60
// False False True True True True False False
// Tablica bitów ba: 13
// True False True True False False False False
// Tablica bitów ba3: ba1 i ba2
// False False True True False False False False
}
static void Main(string[] args)
{
Console.WriteLine("Lists");
// List is like an array but elements can be added and removed dynamically
// The Generic Collection List<T> requires all elments to be of the same type T
// Some List<T> methods:
List <int> li = new List <int>();
li.Add(56);
li.Add(2);
li.Add(1);
li.Add(86);
li.Add(6);
li.Add(26);
PrintList(li);
li.RemoveAt(1);
PrintList(li);
li.Sort();
PrintList(li);
/*
* some noteworthy List<T> methods:
* Capacity: how much space is left before a resize becomes necessary[property]
* Clear(): remove everything
* TrimExcess(): set capacity to the actual number of elements, usefull to free memory
* AddRange(IEnumerable coll): adds the elements of the collection coll to the end of the List<T> [same type required]
* IEnumerable is the collections interface that supports simple iteration over the collection.
* Insert (int i, T t): insert element t at position i
* InsertRange(int i, IEnumerable coll): inserts the elements of a collection coll at a specific index i
* in List<T>
* Remove(T t): Removes the first occourence of object t in the list
* RemoveRange(int i, int count): guess...
* Contains(T t): returns true if the specified element t is present in the list
* IndexOf(T t): guess...
* Reverse(): reverses the orger of the elements in the list
* toArray(): Copies the elements of the list into a new array
*
*/
Console.WriteLine("SortedList<K,V>");
/*
* SortedList is a collection of key/value pairs sorted by key
* Keys are used to retrieve the corresponding values.
* Keys must be unique
* All keys must be of the same type K and values must be of type V
*
* Some properties
* Count - guess...
* Item[K key] gets or sets the value associated to the specific key.
* Item is the indexer and is not required, you can use the brakets[]
* Keys - gets a sorted and indexed collection containing only the keys in a sorted list
*
* Some Methods:
* Add(K key, V value) - adds an element with a specific key
* Remove(K key) - removes the key/value pair with the specified key
*/
SortedList <string, int> sl = new SortedList <string, int>();
sl.Add("meaning of life", 42);
sl.Add("A", 1);
sl.Add("test", 123);
PrintSortedList(sl);
sl.Remove("A");
PrintSortedList(sl);
Console.WriteLine("BitArray");
/*
* Bit Array - Collection of bits
* Usefull to represent a simple group of boolean flags
*
* Props:
* Count
* IsReadOnly
*
* Methods:
* Get(int i)
* Set(int i, bool value)
* SetAll(bool value)
* And(BitArray ba)
* Or(BitArray ba)
* Not()
* Xor(BitArray ba)
*/
BitArray ba1 = new BitArray(4);
BitArray ba2 = new BitArray(4);
ba1.SetAll(true);
ba2.SetAll(false);
PrintBarr("ba1", ba1);
PrintBarr("ba2", ba2);
Console.WriteLine();
PrintBarr("ba1 And ba2", ba1.And(ba2));
PrintBarr("Not ba2", ba1.Not());
Console.ReadKey();
}
static void Main(string[] args)
{
//LECCION 3
//Se meten bytes como si fueran bits. (de 8 en 8)
//Ojo se rellena el array con el bit menos significativo de cada byte
BitArray bits = new BitArray(new byte[] { 1, 2, 4, 8, 16 });
//Contar elementos.
Console.WriteLine(bits.Count);
listar(bits, "bits");
Console.WriteLine("-------");
//Obtener un bit en particular (según posicion)
Console.WriteLine(bits.Get(0));
Console.WriteLine(bits.Get(1));
Console.WriteLine("-------");
//Establecer valor de un bit según su posicion
bits.Set(4, true);
listar(bits, "bits");
//LECCION 4
//Clonación de bitarray (se necesita hacer un cast porque devuelve un objeto)
BitArray bits2 = (BitArray)bits.Clone();
Console.WriteLine("-------");
listar(bits, "bitArray original");
listar(bits2, "bitArray clonado");
//invertimos arreglo con not
Console.WriteLine("-------");
listar(bits2, "bits2 ");
listar(bits2.Not(), "not bits2"); //al hacer el not, se cambia el valor de bits2.
listar(bits2, "bits2 ");
//Otro arrayBit para hacer operaciones con el
BitArray bits3 = new BitArray(new byte[] { 5, 7, 9, 13, 15 });
BitArray temp;
//OR
Console.WriteLine("-------");
temp = new BitArray(new byte[] { 4, 8, 19, 11, 15 });
listar(temp, "temp ");
listar(bits3, "bits3 ");
listar(temp.Or(bits3), "OR ");
//AND
Console.WriteLine("-------");
temp = new BitArray(new byte[] { 4, 8, 19, 11, 15 });
listar(temp, "temp ");
listar(bits3, "bits3 ");
listar(temp.And(bits3), "AND ");
//XOR
Console.WriteLine("-------");
temp = new BitArray(new byte[] { 4, 8, 19, 11, 15 });
listar(temp, "temp ");
listar(bits3, "bits3 ");
listar(temp.Xor(bits3), "XOR ");
Console.ReadKey();
}
private BitArray And() //3
{
ThirdOperand = new BitArray(FirstOperand);
ThirdOperand.And(SecondOperand);
return(ThirdOperand);
}
public FreezableBitArray And(BitArray other)
{
_CheckReadonly();
m_ba.And(other);
return(this);
}
// 隣接判定、ノードごとの処理
public void NodeCheckAction(NodeController.NodeLinkTaskChecker Tc, _eLinkDir Link)
{
NodeDebugLog += "NodeCheckAction. CheckerID : " + Tc.ID + "\n";
// チェック済みでスキップ
if (bChecked) { Tc.Branch--; return; }
// 各種変数定義
bool bBranch = false;
bChecked = true;
Tc.SumNode++;
bChain = false;
// お隣さんを更新
UpdateNegibor();
// 状態表示
Tc += (ToString() + "Action \n Link : " + bitLink.ToStringEx() + "\nNegibor : " + Negibor.ToStringEx());
Tc += Tc.NotFin + " : " + Tc.Branch.ToString();
// チェックスタート
// 接地判定（根本のみ）
if (Link == _eLinkDir.NONE) // 根本か確認
{
if (!bitLink[(int)_eLinkDir.RD] && !bitLink[(int)_eLinkDir.LD]) // 下方向チェック
{
Tc.Branch--;
Tc.SumNode--;
bChecked = false;
return; // 繋がってないなら未チェックとして処理終了
}
// 繋がっている
Tc += ("Ground");
}
// この時点で枝が繋がっている事が確定
bChain = true;
Tc.NodeList.Add(this); // チェッカに自身を登録しておく
// 終端ノードであれば、周囲チェック飛ばす
var TempBit = new BitArray(6);
// 除外方向設定
TempBit.SetAll(false);
if (Link == _eLinkDir.NONE)
{
TempBit.Set((int)_eLinkDir.RD, true);
TempBit.Set((int)_eLinkDir.LD, true);
}
else {
TempBit.Set((int)Link, true);
}
TempBit.And(bitLink).Xor(bitLink); // 自身の道とAND後、自身の道とXOR。
if (TempBit.isZero()) // 比較して一致なら除外方向以外に道がない = XOR後に全0なら終端
{
Tc.Branch--; // 終端ノードであればそこで終了
return;
}
// 周囲のチェック
// この時点で、TempBitは先が壁の道を除いた自分の道を示している。
Tc += "ExcludeFrom MyWay : " + TempBit.ToStringEx();
for (int n = 0; n < (int)_eLinkDir.MAX; n++)
{
var TempBit2 = new BitArray(6);
// 隣接ノードのうち、道が無い場所に自分の道が伸びてたらそこは途切れている。
TempBit2 = TempBit.retAnd(Negibor.retNot());
// ノード繋がってない
if (TempBit2[n])
{
nodeControllerScript.unChainController.AddObj(this, (_eLinkDir)n);
Tc.NotFin = true; // 隣と繋がってないので、枝未完成として登録
}
}
Tc += ("Negibor : " + Negibor.ToStringEx());
TempBit.And(Negibor); // 隣接ノードと繋がっている場所を特定
Tc += "Linked : " + TempBit.ToStringEx();
for (int n = 0; n < (int)_eLinkDir.MAX; n++)
{
if (!TempBit[n]) { continue; } // ビット立ってないならスキップ
// お隣さんと繋がっているので、処理引き渡しの準備
bChain = true;
// デバック表示
Tc += ("Linked [" + LinkDirToString(n) + "]");
// 接続先がおかしいならノーカンで
Vec2Int Target = nodeControllerScript.GetDirNode(nodeID, (_eLinkDir)n);
if (Target.x == -1) { continue; }
// 分岐を検出してカウント
if (!bBranch)
{
bBranch = true; // 一回目ならノーカン
}
else {
Tc.Branch++; // 二回目以降は分岐なので、枝カウンタを+1
}
// 次へ引き渡す
Node TgtNode = nodeControllerScript.GetNodeScript(Target);
if (TgtNode.IsOutPuzzle)
{
Tc.Branch--; // 接続先が壁なら処理飛ばして枝解決
}
else {
// 周囲のActionをトリガーさせる
Observable
.Return(TgtNode)
.Subscribe(_ => {
TgtNode.NodeCheckAction(Tc, (_eLinkDir)((n + 3 >= 6) ? (n + 3 - 6) : (n + 3)));
}).AddTo(this);
}
}
if (Tc.NotFin && Tc.Branch > 0)
{
Tc.Branch--;
}
}
private void hideText(object sender, RoutedEventArgs e)
{
if (TextForHiding.Text.Length != 0)
{
var dialogWindow = new OpenFileDialog();
dialogWindow.ShowDialog();
dialogWindow.InitialDirectory = @"С:\\Users\Dell\Documents\ЗИиНИС\KP_ZIINIS\bin\Debug";
try
{
if (dialogWindow.FileName.Substring(dialogWindow.FileName.Length - 3, 3).Equals("wav"))
{
using (FileStream fstream = new FileStream(dialogWindow.FileName, FileMode.OpenOrCreate))
{
String bitsString = stringToStringOfBits(TextForHiding.Text);
byte[] readBytesArray = new byte[bitsString.Length * 2];
BitArray mask = new BitArray(bitsString.Length * 2 * 8);
mask.SetAll(true);
for (int i = 0; i < mask.Length; i++)
{
if ((i) % 16 == 0)
{
mask.Set(i, false);
}
}
BitArray bitsForHiding = new BitArray(bitsString.Length * 2 * 8);
bitsForHiding.SetAll(false);
for (int i = 0; i < bitsString.Length; i++)
{
if (bitsString[i].Equals('1'))
{
bitsForHiding.Set(i * 16, true);
}
}
BitArray bits2;
fstream.Seek(44, SeekOrigin.Begin);
fstream.Read(readBytesArray, 0, readBytesArray.Length);
if (TextForHiding.Text.Length * 128 < fstream.Length)
{
bits2 = new BitArray(readBytesArray);
bits2.And(mask);
bits2.Xor(bitsForHiding);
fstream.Seek(44, SeekOrigin.Begin);
byte[] hidingbits = BitArrayToByteArray(bits2);
fstream.Write(hidingbits, 0, hidingbits.Length);
MessageBox.Show("Ваш текст спрятан");
TextForHidingLength.Text = TextForHiding.Text.Length.ToString();
}
else
{
MessageBox.Show("Введён слишком длинный текст");
}
}
}
else
{
MessageBox.Show("Выбран файл неверного формата, нужен формат .wav ");
}
}
catch (Exception ex)
{
MessageBox.Show($"Исключение: {ex.Message}");
}
}
else
{
MessageBox.Show("Введите спрятанный текст");
}
}
internal virtual void DoRandomSets(int maxSize, int iter, int mode)
{
BitArray a0 = null;
LongBitSet b0 = null;
for (int i = 0; i < iter; i++)
{
int sz = TestUtil.NextInt(Random(), 2, maxSize);
BitArray a = new BitArray(sz);
LongBitSet b = new LongBitSet(sz);
// test the various ways of setting bits
if (sz > 0)
{
int nOper = Random().Next(sz);
for (int j = 0; j < nOper; j++)
{
int idx;
idx = Random().Next(sz);
a.SafeSet(idx, true);
b.Set(idx);
idx = Random().Next(sz);
a.SafeSet(idx, false);
b.Clear(idx);
idx = Random().Next(sz);
a.SafeSet(idx, !a.Get(idx));
b.Flip(idx, idx + 1);
idx = Random().Next(sz);
a.SafeSet(idx, !a.SafeGet(idx));
b.Flip(idx, idx + 1);
bool val2 = b.Get(idx);
bool val = b.GetAndSet(idx);
Assert.IsTrue(val2 == val);
Assert.IsTrue(b.Get(idx));
if (!val)
{
b.Clear(idx);
}
Assert.IsTrue(b.Get(idx) == val);
}
}
// test that the various ways of accessing the bits are equivalent
DoGet(a, b);
// test ranges, including possible extension
int fromIndex, toIndex;
fromIndex = Random().Next(sz / 2);
toIndex = fromIndex + Random().Next(sz - fromIndex);
BitArray aa = (BitArray)a.Clone();
aa.Flip(fromIndex, toIndex);
LongBitSet bb = b.Clone();
bb.Flip(fromIndex, toIndex);
fromIndex = Random().Next(sz / 2);
toIndex = fromIndex + Random().Next(sz - fromIndex);
aa = (BitArray)a.Clone();
aa.Clear(fromIndex, toIndex);
bb = b.Clone();
bb.Clear(fromIndex, toIndex);
DoNextSetBit(aa, bb); // a problem here is from clear() or nextSetBit
DoPrevSetBit(aa, bb);
fromIndex = Random().Next(sz / 2);
toIndex = fromIndex + Random().Next(sz - fromIndex);
aa = (BitArray)a.Clone();
aa.Set(fromIndex, toIndex);
bb = b.Clone();
bb.Set(fromIndex, toIndex);
DoNextSetBit(aa, bb); // a problem here is from set() or nextSetBit
DoPrevSetBit(aa, bb);
if (b0 != null && b0.Length() <= b.Length())
{
Assert.AreEqual(a.Cardinality(), b.Cardinality());
BitArray a_and = (BitArray)a.Clone();
a_and = a_and.And(a0);
BitArray a_or = (BitArray)a.Clone();
a_or = a_or.Or(a0);
BitArray a_xor = (BitArray)a.Clone();
a_xor = a_xor.Xor(a0);
BitArray a_andn = (BitArray)a.Clone();
a_andn.AndNot(a0);
LongBitSet b_and = b.Clone();
Assert.AreEqual(b, b_and);
b_and.And(b0);
LongBitSet b_or = b.Clone();
b_or.Or(b0);
LongBitSet b_xor = b.Clone();
b_xor.Xor(b0);
LongBitSet b_andn = b.Clone();
b_andn.AndNot(b0);
Assert.AreEqual(a0.Cardinality(), b0.Cardinality());
Assert.AreEqual(a_or.Cardinality(), b_or.Cardinality());
Assert.AreEqual(a_and.Cardinality(), b_and.Cardinality());
Assert.AreEqual(a_or.Cardinality(), b_or.Cardinality());
Assert.AreEqual(a_xor.Cardinality(), b_xor.Cardinality());
Assert.AreEqual(a_andn.Cardinality(), b_andn.Cardinality());
}
a0 = a;
b0 = b;
}
}
public static bool Contains(this BitArray a, BitArray rhs)
{
BitArray tmp = a.And(rhs);
return(tmp.EqualsReal(rhs));
}
public static void OperatorTest(Operator op)
{
BitArray bitArray1 = new BitArray(6, false);
BitArray bitArray2 = new BitArray(6, false);
BitArray result;
bitArray1.Set(0, true);
bitArray1.Set(1, true);
bitArray2.Set(1, true);
bitArray2.Set(2, true);
switch (op)
{
case Operator.Xor:
result = bitArray1.Xor(bitArray2);
Assert.Same(bitArray1, result);
Assert.True(result.Get(0));
Assert.False(result.Get(1));
Assert.True(result.Get(2));
Assert.False(result.Get(4));
break;
case Operator.And:
result = bitArray1.And(bitArray2);
Assert.Same(bitArray1, result);
Assert.False(result.Get(0));
Assert.True(result.Get(1));
Assert.False(result.Get(2));
Assert.False(result.Get(4));
break;
case Operator.Or:
result = bitArray1.Or(bitArray2);
Assert.Same(bitArray1, result);
Assert.True(result.Get(0));
Assert.True(result.Get(1));
Assert.True(result.Get(2));
Assert.False(result.Get(4));
break;
}
// Size stress cases.
bitArray1 = new BitArray(0x1000F, false);
bitArray2 = new BitArray(0x1000F, false);
bitArray1.Set(0x10000, true); // The bit for 1 (2^0).
bitArray1.Set(0x10001, true); // The bit for 2 (2^1).
bitArray2.Set(0x10001, true); // The bit for 2 (2^1).
switch (op)
{
case Operator.Xor:
result = bitArray1.Xor(bitArray2);
Assert.Same(bitArray1, result);
Assert.True(result.Get(0x10000));
Assert.False(result.Get(0x10001));
Assert.False(result.Get(0x10002));
Assert.False(result.Get(0x10004));
break;
case Operator.And:
result = bitArray1.And(bitArray2);
Assert.Same(bitArray1, result);
Assert.False(result.Get(0x10000));
Assert.True(result.Get(0x10001));
Assert.False(result.Get(0x10002));
Assert.False(result.Get(0x10004));
break;
case Operator.Or:
result = bitArray1.Or(bitArray2);
Assert.Same(bitArray1, result);
Assert.True(result.Get(0x10000));
Assert.True(result.Get(0x10001));
Assert.False(result.Get(0x10002));
Assert.False(result.Get(0x10004));
break;
}
}
public static void Subtract(BitArray a, BitArray b) // a = a - b
{
BitArray c = (BitArray)b.Clone();
a.And(c.Not());
}
public static void And_Invalid()
{
BitArray bitArray1 = new BitArray(11, false);
BitArray bitArray2 = new BitArray(6, false);
// Different lengths
Assert.Throws<ArgumentException>(null, () => bitArray1.And(bitArray2));
Assert.Throws<ArgumentException>(null, () => bitArray2.And(bitArray1));
Assert.Throws<ArgumentNullException>("value", () => bitArray1.And(null));
}
/// <summary>
/// Create reachability matrix of all pods
/// egressMatrix takes egress pods as row and ingress pods as column
/// ingressMatrix takes ingress pods as row and egress pods as column
/// egressMatrix is the transpose of ingressMatrix
///
/// PodA can send traffic to podB if and only if.
/// podA is allowed to send traffic to podB and podB is allowed to receive traffic from podA.
/// </summary>
/// <param name="pods">all pods.</param>
/// <param name="policies">all policies.</param>
/// <param name="namespaces">all namespaces.</param>
/// <returns>two reachability matrices and three BCP matrices.</returns>
public static (Zen <IList <bool> >[] egressMatrix, Zen <IList <bool> >[] ingressMatrix, Zen <IList <bool> >[] podPolMatrix, Zen <IList <bool> >[] polPodAllowedMatrix, Zen <IList <bool> >[] polPodSelectedMatrix) CreateReachMatrix(Zen <Pod>[] pods, Zen <Policy>[] policies, Zen <Namespace>[] namespaces)
{
var n = pods.Length;
var m = policies.Length;
// BCP
var selectedPolicies = new bool[n, m];
var allowedPods = new bool[m, n];
var selectedPods = new bool[m, n];
/***********************ns filter*********************/
// Create ns-pod mapping
Dictionary <int, BitArray> nsMatrix = new Dictionary <int, BitArray>();
for (int i = 0; i < n; ++i)
{
var ns = pods[i].GetNS();
var hash = ns.GetHashCode();
if (!nsMatrix.ContainsKey(hash))
{
nsMatrix[hash] = new BitArray(n);
}
nsMatrix[hash].Set(i, true);
}
// Create label-ns mapping
var nsSize = namespaces.Length;
Dictionary <int, BitArray> nsLabelHash = new Dictionary <int, BitArray>();
for (int i = 0; i < nsSize; ++i)
{
var keys = namespaces[i].GetLabelKeys();
var k = keys.Length();
// iterate over Zen<List> to traverse all labels
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var keyHash = keys.At(k).Value().GetHashCode();
if (!nsLabelHash.ContainsKey(keyHash))
{
nsLabelHash[keyHash] = new BitArray(nsSize);
}
nsLabelHash[keyHash].Set(i, true);
}
}
/*****************************************************/
// Create label-pod mapping
Dictionary <int, BitArray> labelHash = new Dictionary <int, BitArray>();
// ingress policy matrix
BitArray[] ingressReachMatrix = new BitArray[n];
// egress policy matrix
BitArray[] egressReachMatrix = new BitArray[n];
for (int i = 0; i < n; ++i)
{
// initialize reachability matrix to allow all traffic (default behavior)
ingressReachMatrix[i] = new BitArray(n, true);
egressReachMatrix[i] = new BitArray(n, true);
var keys = pods[i].GetKeys();
var k = keys.Length();
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var keyHash = keys.At(k).Value().GetHashCode();
if (!labelHash.ContainsKey(keyHash))
{
labelHash[keyHash] = new BitArray(n);
}
labelHash[keyHash].Set(i, true);
}
}
// record which pods have been selected
// if a pod has not been selected, it by default allows all traffic
var podSelected = new bool[n];
// Traverse all policies to create reachability matrix
for (int i = 0; i < m; ++i)
{
// bitvector of selected pods (keys of labels only)
var selectSet = new BitArray(n, true);
// if policy is in a namespace which has no pods, this policy is void (no pods can be selected)
if (!nsMatrix.ContainsKey(policies[i].GetNS().GetHashCode()))
{
continue;
}
// else select pods only in the namespace of the policy
selectSet.And(nsMatrix[policies[i].GetNS().GetHashCode()]);
var keys = policies[i].GetSelectKeys();
var k = keys.Length();
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var keyHash = keys.At(k).Value().GetHashCode();
// if a label(key) doesn't exist in all pods, no pods are selected
if (!labelHash.ContainsKey(keyHash))
{
selectSet.SetAll(false);
break;
}
// else intersect with pods under the key
selectSet = selectSet.And(labelHash[keyHash]);
}
// bitvector of allowed ns
var allowNSSet = new BitArray(nsSize);
// bitvector of allowed pods
var allowSet = new BitArray(n);
{
// get all namespaces that match label key of allowed ns
var allowNSKeys = policies[i].GetAllowNSKeys();
var allowNSLabels = policies[i].GetAllowNS();
k = allowNSKeys.Length();
// if this policy is deny all, no pods are allowed to/from selected pods
if (policies[i].GetDenyAll().Equals(True()))
{
allowSet.SetAll(false);
}
// if this policy is allow all, all pods are allowed to/from selected pods
else if (policies[i].GetAllowAll())
{
allowSet.SetAll(true);
}
// if no labels of allowed ns is defined in the policy,
// namespace of the policy will be used as allowed ns
else if (k.EqualToNumber(0))
{
allowSet.Or(nsMatrix[policies[i].GetNS().GetHashCode()]);
}
// else tranverse all labels of allowed ns
else
{
// Get ns matchs all keys of allowed labels
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var keyHash = allowNSKeys.At(k).Value().GetHashCode();
if (!nsLabelHash.ContainsKey(keyHash))
{
allowNSSet.SetAll(false);
break;
}
allowNSSet.Or(nsLabelHash[keyHash]);
}
// Check if selected namespaces have same label values as required in policy
for (int j = 0; j < nsSize; ++j)
{
if (allowNSSet.Get(j))
{
var nsLabels = namespaces[j].GetLabels();
k = allowNSKeys.Length();
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var key = allowNSKeys.At(k).Value();
// if label value is not matched, this ns is not allowed
if (!allowNSLabels.Get(key).Value().GetHashCode().Equals(nsLabels.Get(key).Value().GetHashCode()))
{
allowNSSet.Set(j, false);
break;
}
}
}
// allowed pods can be only in the allowed ns
if (allowNSSet.Get(j))
{
allowSet.Or(nsMatrix[namespaces[j].GetName().GetHashCode()]);
}
}
}
}
var labels = policies[i].GetAllowLabels();
keys = policies[i].GetAllowKeys();
k = keys.Length();
// tranverse labels(key) of allowed pods
// intersect pods under required labels(key)
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var keyHash = keys.At(k).Value().GetHashCode();
if (!labelHash.ContainsKey(keyHash))
{
allowSet.SetAll(false);
break;
}
allowSet = allowSet.And(labelHash[keyHash]);
}
// check if pods have the same label values as required
for (int j = 0; j < n; ++j)
{
if (allowSet.Get(j))
{
k = keys.Length();
var podLabels = pods[j].GetLabels();
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var key = keys.At(k).Value();
var value = labels.Get(key).Value();
if (!podLabels.Get(key).Value().StringValue().Equals(value.StringValue()))
{
allowSet.Set(j, false);
break;
}
}
}
// update BCP policy-pod mapping
if (allowSet.Get(j))
{
allowedPods[i, j] = true;
}
}
labels = policies[i].GetSelectLabels();
keys = policies[i].GetSelectKeys();
var reachMatrix = ingressReachMatrix;
if (!policies[i].GetIngress().Equals(True()))
{
reachMatrix = egressReachMatrix;
}
// tranverse labels(key) of pod selector
// intersect pods under required labels(key)
for (int j = 0; j < n; ++j)
{
if (selectSet.Get(j))
{
k = keys.Length();
var podLabels = pods[j].GetLabels();
for (k -= 1; !k.EqualToNumber(ushort.MaxValue); k -= 1)
{
var key = keys.At(k).Value();
var value = labels.Get(key).Value();
if (!podLabels.Get(key).Value().StringValue().Equals(value.StringValue()))
{
selectSet.Set(j, false);
break;
}
}
}
if (selectSet.Get(j))
{
// if this pod has not been selected before, set all its reach bits to 0
if (!podSelected[j])
{
podSelected[j] = true;
ingressReachMatrix[j].SetAll(false);
egressReachMatrix[j].SetAll(false);
// intra-pod traffic is always allowed
ingressReachMatrix[j].Set(j, true);
egressReachMatrix[j].Set(j, true);
}
// update BCP selected mapping
selectedPolicies[j, i] = true;
selectedPods[i, j] = true;
// allow pods to/from selected pod
reachMatrix[j] = reachMatrix[j].Or(allowSet);
}
}
}
// only ingress policy allows podA to receive traffic from podB
// and egress policy allows podB to send traffic to podA
// podA can receive traffic from podB
ingressReachMatrix.Transpose();
for (int i = 0; i < n; ++i)
{
egressReachMatrix[i].And(ingressReachMatrix[i]);
}
// ingress matrix is transpose of egress matrix
ingressReachMatrix = egressReachMatrix.Select(v => (BitArray)v.Clone()).ToArray();
ingressReachMatrix.Transpose();
// create Zen data:
// 1. egress matrix
// 2. ingress matrix
// 3. BCP pod-policy mapping
// 4. BCP policy-pod allowed mapping
// 5. BCP policy-pod selected mapping
Zen <IList <bool> >[] eMx = new Zen <IList <bool> > [n];
Zen <IList <bool> >[] inMx = new Zen <IList <bool> > [n];
Zen <IList <bool> >[] podPolMx = new Zen <IList <bool> > [n];
Zen <IList <bool> >[] polPodAllowedMx = new Zen <IList <bool> > [m];
Zen <IList <bool> >[] polPodSelectedMx = new Zen <IList <bool> > [m];
for (int i = 0; i < n; ++i)
{
var tmp = new bool[n];
egressReachMatrix[i].CopyTo(tmp, 0);
eMx[i] = tmp;
ingressReachMatrix[i].CopyTo(tmp, 0);
inMx[i] = tmp;
// BCP pod-policy mapping
podPolMx[i] = Enumerable.Range(0, m).Select(x => selectedPolicies[i, x]).ToArray();
}
for (int i = 0; i < m; ++i)
{
// BCP policy-pod mapping
polPodAllowedMx[i] = Enumerable.Range(0, n).Select(x => allowedPods[i, x]).ToArray();
polPodSelectedMx[i] = Enumerable.Range(0, n).Select(x => selectedPods[i, x]).ToArray();
}
return(eMx, inMx, podPolMx, polPodAllowedMx, polPodSelectedMx);
}
static void Main(string[] args)
{
/* Generics - allows the reuse of code across different types.
* For example, let's declare a method that swaps the values of its two parameters
*
* static void Swap(ref int a, ref int b)
* {
* int temp = a;
* a = b;
* b = temp;
* }
*
* Our Swap method will work only for integer parameter. If we want to use it for other types, for example, doubles or strings,
* we have to overload it for all the types we want to use it with. Beside a lot of code repetition, it becomes harder to
* manage the code because changes in one method mean changes to all of the overloaded methods.
* Generics provide a flexible mechanism to define a generic type.
* example line(12)
*
* static void Swap<T>(ref T a, ref T b)
* {
* T temp = a;
* a = b;
* b = temp;
* }
*
* In the above code, T is the name of our generic type, We can name it anything we want, but T is a commonly used name. Our Swap method
* now takes two parameters of type T. We also use the T type for our temp variable that is used to swap the values.
*
* Note the brackets in the syntax <T>, which re used to define a generic type.
* We can now use our Swap method with different types, as in below and line(12)
*/
int a = 4, b = 9;
Swap <int>(ref a, ref b);
Console.WriteLine(a + " " + b); //output 9 4
string x = "Hello";
string y = "World!";
Swap <string>(ref x, ref y);
Console.WriteLine(x + " " + y); //output World Hello
/*When calling a generic method, we need to specify the type it will work with by using brackets. So when Swap<int> is called, the T type
* is replaced by int. For Swap<string>, T is replace by string.
* If you omit specifying the type when calling a generic method, the compiler will use the type based on the arguments passed to the method
*
* Mulitiple generic parameters can be used with a single method.
* For example: Func<T, U> takes two different generic types.
*/
/* Generic Classes -
* generic types can also be used with classes. The most common use for generic classes is with collections of items, where operations such as
* adding and removing items from the collection are performed in basically the same way regardless of the type of data being stored.
* One type of collection is called a stack. Items are "pushed", or added to the collection, and "popped", or removed from the collection.
* A stack is sometimes called a Last in First Out(LIFO) data structure.
* for example - line(20)
*
* The generic class stores elements in an array. As you can see, the generic type T is used as the type of the array, the parameter
* type for the Push method, and the return type for the Pop and Get methods.
* Now we can create objects of our generic class as below
*/
Stack <int> IntStack = new Stack <int>();
Stack <string> strStack = new Stack <string>();
//Stack<Person> PersonStack = new Stack<Person>()
/*We can also use the generic class with custom types, such as the custom defined Person type.
* In a generic class we do not need to define the generic type for its methods, because the generic type is already defined on the class level.
* Generic class methods are called the same as for any other object.
*/
Stack <int> intStack2 = new Stack <int>();
intStack2.Push(3);
intStack2.Push(6);
intStack2.Push(7);
Console.WriteLine(intStack2.Get(1));
/*C# Collections
* A collection is used to group related objects. Unlike an array, it is dynamic and can also group objects. A collection can grow
* and shrink to accommodate any number of objects. Collection classes are organized into namespaces and contain built in methods for
* processing elements within the collection.
* A collection organizes related data in a computer so that it can be used efficiently.
* Different kinds of collections are suited to different kinds of applications and some are highly specialized to specific tasks.
* For example,
* Dictionaries are used to represent connections on social websites (such as Twitter, Facebook),
* Queues can be used to create task schedulers,
* HashSets are used in searching algorithms, etc
*
* A collection typically includes methods to add, remove and count objects.
* The for statement and foreach statement are used to iterate through collections. Since a collection is a class you must first declare an
* instance of the class before you can add elements to that collection.
* For example as below
* List<int> li = new List<int>();
*
* Collections provide a more flexible way to work with groups of objects. Unlike arrays, the group of objects you work with can grow and shrink
* dynamically as the needs of the application change
*
*
* Generic Collections
* Generic collections are the preferred type to use as long as every element in the collection is of the same data type. Only desired data types can
* can be added to a generic collection and this is enforced by using strong typing which reduces the possibility of errors.
* The .NET framework provides a number of generic collection classes, useful for storing and manipulating data.
* The System.Collections.Generic namespace includes the following generic collections:
* - List<T>
* - Dictionary<TKey, TValue>
* - SortedList<TKey, TValue>
* - Stack<T>
* - Queue<T>
* - Hashset<T>
*
* To access a generic collection in your code, you will need to include the statement: using System.Collections.Generic;
*
*
* Non-Generic Collections -
* Non-generic collections can store items that are of type Object. Since an Object data type can refer to any data type,
* you run the risk of unexpected outcomes. Non-generic collections may also be slower to access as well as execute.
* The System.Collections namespace includes the following non-generic collections:
* - ArrayList
* - SortedList
* - Stack
* - Queue
* - Hashtable
* - BitArray
*
* Because non-generic collections are error prone and less performant, it is recommended to always use generic collections from the
* System.Collections.Generic namespace if available and to avoid using legacy collections from the System.Collections namespace
*
*/
/*Lists and BitArray
* - List<T> - A list is similar to an array, but the elements in a list can be inserted and removed dynamically.
* C# generic collection List<T> class requires all elements be of the same type T.
*
* List<T> properties and methods include:
* - Count : A property that gets the number of elements contained in the list
* - Item[int i] : Gets or sets the element in the list at the index i. Item is the indexer and is not required when accessing an element. You only
* need to use the brackets[] and the index value inside the brackets.
* - Add(T t) : Adds an element t to the end of the list.
* - RemoveAt(int index) : Removes the element at the specified position (index) from the list.
* - Sort() : Sorts elements in the list
* See few examples of List<T> below
*/
List <int> li = new List <int>();
li.Add(59);
li.Add(72);
li.Add(95);
li.Add(5);
li.Add(9);
li.Remove(1); //removes 72
Console.Write("\nList: ");
for (int xi = 0; xi < li.Count; xi++)
{
Console.Write(li[xi] + " "); //59, 95, 5, 9
}
li.Sort();
Console.Write("\nSorted: ");
for (int xi = 0; xi < li.Count; xi++)
{
Console.Write(li[xi] + " "); // 5 9 59 95
}
/*Additional List<T> properties and methods are listed below. Try them out by adding them to the List<T> example code above.
* - Capacity : A property that gets the number of elements the list can hold before needing to be resized
* - Clear() : Removes all the elements from the list
* - TrimExcess() : Sets the capacity to the actual number of elements in the list. This is useful when trying to reduce memory overhead.
* - AddRange(IEnumerable coll) : Adds the elements of collection coll with elements of the same type as List<T> to the end of the list. IEnumerable
* is the collections interface that supports simple iteration over the collection.
* - Insert(int i, T t) : inserts an element t at a specific index i in the list
* - InsertRange(int i, IEnumerable coll) : Inserts the elements of a collection coll at a specified index i in the list. IEnumerable is the collections
* interface that supports simple iteration over the collection.
* - Remove(T t) : Removes the first occurence of the object t from the list.
* - RemoveRange(int i, int count) : Removes a specified number of elements count from the list starting at a specified index i.
* - Contains(T t) : Returns true if the specified element t is present in the list
* - IndexOf(T t) : Returns the index of the first occurrence of the element t in the list.
* - Reverse() : Reverses the order of the elements in the list
* - ToArray() : Copies the elements of the list into a new array
*
*/
/*SortedList<k,V>
* A sorted list is a collection of key/value pairs that are sorted by key. A key can be used to access its corresponding value in the sorted list
* C# generic collection SortedList<K, V> class requires all element key/value pairs to be of the same type K, V. Duplicate keys are not permitted,
* which ensures that every key/value pair is unique.
*
* SortedList<k, V> properties include:
* - Count : Gets the number of key/value pairs contained in the sorted list
* - Item[K key] : Gets or sets the value associated with the specified key contained in the sorted list. Item is the indexer and is not required
* when accessing an element. You only need to use the brackets[] and the key, value.
* - key : Gets a sorted and indexed collection containing only the keys in the sorted list
*
* SortedList<K, V> methods include:
* - Add(K key, V value) : Adds an element with a specific key, value pair into the sorted list.
* - Remove(K key) : Removes the element with the specific key, value pair associated with the specified key from the sorted list.
* example os SortedList below
*/
SortedList <string, int> s1 = new SortedList <string, int>();
s1.Add("Stanley", 59);
s1.Add("the", 95);
s1.Add("Ikechukwu", 72);
s1.Remove("the");
Console.WriteLine("Sorted List: ");
foreach (string s in s1.Keys)
{
Console.WriteLine(s + ": " + s1[s]); //Ikechukwu: 72 Stanley: 59
}
Console.WriteLine("\nCount: " + s1.Count); //Count: 2
/*Here are additional SortedList<K, V> properties and methods:
* - Values : Gets a sorted and indexed collection of the values in the sorted list
* - Clear() : removes all the elements from the sorted list
* - ContainsKey(K key) : Returns true when the specified key is present in the sorted list
* - IndexOfKey(K key) : Returns the index of the specified key within the sorted list
* - IndexOfValue(V value) : Returns the index of the specified value within the sorted list
*/
/*BitArray
* A bit array is a collection of bits. The value of a bit can be either 0 (off/false) or 1 (on/true).
* Bit array compactly store bits. Most commonly, they are used to represent a simple group of boolean flags or an ordered sequence of boolean
* values.
* BitArray Properties includes:
* - Count : Gets the number of bits in the bit array
* - IsReadOnly : Gets a value indicating if the bit array is read only or not
*
* BitArray methods include:
* - Get(int i) : Gets the value of the bit at a specified position i in the bit array.
* - Set(int i, bool value) : Sets the bit at a specified position i to a specified value in the bit array
* - SetAll(bool value) : Sets all the bits to a specified value in the bit array.
* - And(BitArray ba) : Performs the bitwise AND operation on the elements of the bit array object with a specified bit array ba.
* - Or(BitArray ba) : Performs the bitwise OR operation on the elements of the bit array and the specified bit array ba
* - Not() : Inverts the bit values of the bit array.
* - Xor(BitArray ba) : Performs the bitwise XOR operation on the elements of the current bit array object and the elements in the specified bit array ba
* see examples on properties and methods of bitArray class below and line (42)
*/
BitArray ba1 = new BitArray(4);
BitArray ba2 = new BitArray(4);
ba1.SetAll(true);
ba2.SetAll(false);
ba1.Set(2, false);
ba2.Set(3, true);
PrintBar("ba1", ba1);
PrintBar("ba2", ba2);
Console.WriteLine();
PrintBar("ba1 AND ba2", ba1.And(ba2));
PrintBar(" Not ba2", ba2.Not());
//one use case of BitArrays is in image processing to store the individual bits of a gray-scale image
}
public BitArray BitArrayAnd() => _original.And(_original2);
public virtual bool runTest()
{
Console.Out.WriteLine("Plain\\System_NewCollections\\BitArray\\Co1550And.cs runTest() started.");
int iCountErrors = 0;
int iCountTestcases = 0;
BitArray ba2 = null;
BitArray ba3 = null;
BitArray ba4 = null;
ba2 = new BitArray(6, false);
ba3 = new BitArray(6, false);
ba2.Set(0, true);
ba2.Set(1, true);
ba3.Set(1, true);
ba3.Set(2, true);
ba4 = ba2.And(ba3);
++iCountTestcases;
if (ba4.Get(0))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_09pv (Co1550And)");
Console.Error.WriteLine("EXTENDEDINFO: 1 & 0 (E_09pv ,Co1550And)");
}
++iCountTestcases;
if (!ba4.Get(1))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_96hf (Co1550And)");
}
++iCountTestcases;
if (ba4.Get(2))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_84si (Co1550And)");
}
++iCountTestcases;
if (ba4.Get(4))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_79kn (Co1550And)");
}
ba2 = new BitArray(0x1000F, false);
ba3 = new BitArray(0x1000F, false);
ba2.Set(0x10000, true);
ba2.Set(0x10001, true);
ba3.Set(0x10001, true);
ba3.Set(0x10002, true);
ba4 = ba2.And(ba3);
++iCountTestcases;
if (ba4.Get(0x10000))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_61ah (Co1550And)");
}
++iCountTestcases;
if (!ba4.Get(0x10001))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_52xd (Co1550And)");
}
++iCountTestcases;
if (ba4.Get(0x10002))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_47op (Co1550And)");
}
++iCountTestcases;
if (ba4.Get(0x10004))
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_54ja (Co1550And)");
}
try
{
BitArray b1 = new BitArray(0);
BitArray b2 = new BitArray(0);
b1.And(b2);
}
catch (Exception exc)
{
++iCountErrors;
Console.WriteLine("Err_001, Exception was not expected " + exc);
}
ba2 = new BitArray(11, false);
ba3 = new BitArray(6, false);
try
{
++iCountTestcases;
ba4 = ba2.And(ba3);
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_66vc (Co1550And)");
}
catch (ArgumentException) {}
catch (Exception)
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_58jq (Co1550And)");
}
ba2 = new BitArray(6, false);
ba3 = new BitArray(11, false);
try
{
++iCountTestcases;
ba4 = ba2.And(ba3);
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_432k (Co1550And)");
}
catch (ArgumentException) {}
catch (Exception)
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_452a (Co1550And)");
}
ba2 = new BitArray(6, false);
ba3 = null;
try
{
++iCountTestcases;
ba4 = ba2.And(ba3);
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_72dg (Co1550And)");
}
catch (ArgumentNullException) {}
catch (Exception)
{
++iCountErrors;
Console.Error.WriteLine("POINTTOBREAK: find error E_93kx (Co1550And)");
}
if (iCountErrors == 0)
{
Console.Error.Write("BitArray\\Co1550And.cs: paSs. iCountTestcases==");
Console.Error.WriteLine(iCountTestcases);
return(true);
}
else
{
Console.Error.Write("Co1550And.cs iCountErrors==");
Console.Error.WriteLine(iCountErrors);
Console.Error.WriteLine("PATHTOSOURCE: BitArray\\Co1550And.cs FAiL !");
return(false);
}
}
public virtual bool ReflexCompatible(GameActor actor, ReflexData reflex, ProgrammingElement replacedElement, bool allowArchivedCategories)
{
// Check actor compatibility
{
if (!this.ActorCompatible(actor))
{
return(false);
}
}
// Build datatype bitmask
{
string selectionUpid = (replacedElement != null) ? replacedElement.upid : null;
scratchOutputs.SetAll(false);
scratchNegOutputs.SetAll(false);
// Set sensor bits
if (reflex.Sensor != null)
{
scratchOutputs.Or(reflex.Sensor.Outputs);
}
else
{
// if no sensor, simulate a boolean output type (for "always" behavior).
scratchOutputs.Set((int)SensorOutputType.Boolean, true);
}
// Set filter bits
foreach (Filter filter in reflex.Filters)
{
// Don't consider the selected one, since we'd be replacing it.
if (filter.upid == selectionUpid)
{
selectionUpid = null;
continue;
}
scratchOutputs.Or(filter.Outputs);
scratchNegOutputs.Or(filter.NegOutputs);
}
// Set actuator bits
if (reflex.Actuator != null)
{
scratchNegOutputs.Or(reflex.Actuator.NegOutputs);
}
// Set selector bits
if (reflex.Selector != null)
{
scratchNegOutputs.Or(reflex.Selector.NegOutputs);
}
// Set modifier bits
foreach (Modifier modifier in reflex.Modifiers)
{
// Don't consider the selected one, since we'd be replacing it.
if (modifier.upid == selectionUpid)
{
selectionUpid = null;
continue;
}
scratchNegOutputs.Or(modifier.NegOutputs);
}
}
// If this element is on the do side, remove negated outputs.
// TODO (****) I just noticed that "this is Filter" is here even though filters
// shouldn't be on the DO side. Is this a bug or do we need this?
if (this is Actuator || this is Selector || this is Modifier || this is Filter)
{
scratchOutputs.And(scratchNegOutputs.Not());
}
// Check datatype compatibility
{
if (this.InputCount > 0 && !MatchesAnyBit(scratchOutputs, this.Inputs))
{
return(false);
}
}
// Build category bitmask
int scratchExclusionCount = 0;
{
string selectionUpid = (replacedElement != null) ? replacedElement.upid : null;
scratchCategories.SetAll(false);
scratchNegations.SetAll(false);
// Set sensor bits
if (reflex.Sensor != null && reflex.Sensor.upid != selectionUpid)
{
scratchCategories.Or(reflex.Sensor.Categories);
scratchNegations.Or(reflex.Sensor.Negations);
}
// Set actuator bits
if (reflex.Actuator != null && reflex.Actuator.upid != selectionUpid)
{
scratchCategories.Or(reflex.Actuator.Categories);
scratchNegations.Or(reflex.Actuator.Negations);
}
// Set selector bits
if (reflex.Selector != null && reflex.Selector.upid != selectionUpid)
{
scratchCategories.Or(reflex.Selector.Categories);
scratchNegations.Or(reflex.Selector.Negations);
}
// Set filter bits
foreach (Filter filter in reflex.Filters)
{
// Don't consider the selected modifier, since we'd be replacing it.
// Don't consider any filters after the selection either, since we need to consider only everything to its left when replacing.
if (filter.upid == selectionUpid)
{
selectionUpid = null;
break;
}
scratchCategories.Or(filter.Categories);
scratchNegations.Or(filter.Negations);
scratchExclusionCount += Math.Max(scratchExclusionCount, filter.ExclusionCount);
}
// Set modifier bits
foreach (Modifier modifier in reflex.Modifiers)
{
// Don't consider the selected modifier, since we'd be replacing it.
// Don't consider any modifiers after the selection either, since we need to consider only everything to its left when replacing.
if (modifier.upid == selectionUpid)
{
selectionUpid = null;
break;
}
scratchCategories.Or(modifier.Categories);
scratchNegations.Or(modifier.Negations);
scratchExclusionCount = Math.Max(scratchExclusionCount, modifier.ExclusionCount);
}
}
// If this element is on the "do" side, remove negated categories.
// Let Negations work on WHEN side also...
//if (this is Actuator || this is Selector || this is Modifier)
{
scratchNegations.Not(); // Invert the negations.
scratchCategories.And(scratchNegations);
}
// Build my inclusion bitmask
{
scratchMyCategories.SetAll(false);
scratchMyCategories.Or(this.Inclusions);
if (allowArchivedCategories)
{
scratchMyCategories.Or(this.ArchivedInclusions);
}
}
#if DEBUG_COMPATIBILITY
if (this.upid == "modifier.it")
{
scratchNegations.Not(); // Restore negations so they dump correctly.
num++;
Debug.Print(num.ToString());
Debug.Print(this.upid);
DumpCategories(this.Inclusions, " inclusions");
DumpCategories(this.Exclusions, " exclusions");
DumpCategories(scratchCategories, " scratch");
DumpCategories(scratchMyCategories, " scratchMy");
DumpCategories(scratchNegations, " scratchNegations");
}
#endif
// Check category compatibility
{
if (this.InclusionCount > 0 && !MatchesAnyBit(scratchCategories, scratchMyCategories))
{
return(false);
}
if (this.ExclusionCount > 0 && MatchesAnyBit(scratchCategories, this.Exclusions))
{
return(false);
}
}
return(true);
}
static void Main(string[] args)
{
byte[] a = { 10 };
byte[] b = { 64 };
byte[] c = { 25 };
BitArray ba1 = new BitArray(8);
BitArray ba2 = new BitArray(8);
BitArray ba3 = new BitArray(8);
ba1 = new BitArray(a);
ba2 = new BitArray(b);
ba3 = new BitArray(c);
Console.WriteLine("First BitArray whose value is 10");
for (int i = 0; i < ba1.Count; i++)
{
Console.Write("{0 , -6}", ba1[i]);
}
Console.WriteLine();
Console.WriteLine("First BitArray whose value is 25");
for (int i = 0; i < ba2.Count; i++)
{
Console.Write("{0 , -6}", ba2[i]);
}
Console.WriteLine();
Console.WriteLine("First BitArray whose value is 64");
for (int i = 0; i < ba3.Count; i++)
{
Console.Write("{0 , -6}", ba3[i]);
}
Console.WriteLine();
Console.WriteLine("BitArray ba2: 13");
for (int i = 0; i < ba2.Count; i++)
{
Console.Write("{0 , -6}", ba1[i]);
}
Console.WriteLine();
BitArray ba4 = new BitArray(8);
ba4 = ba1.And(ba2);
Console.WriteLine("After AND operation:");
for (int i = 0; i < ba4.Count; i++)
{
Console.Write("{0 , -6}", ba4[i]);
}
Console.WriteLine();
ba4.Set(3, true);
Console.WriteLine("After SET operation:");
for (int i = 0; i < ba4.Count; i++)
{
Console.Write("{0 , -6}", ba4[i]);
}
Console.WriteLine();
ba4 = ba1.Or(ba2);
Console.WriteLine("After OR operation:");
for (int i = 0; i < ba4.Count; i++)
{
Console.Write("{0 , -6}", ba4[i]);
}
Console.WriteLine();
ba4 = ba1.Xor(ba2);
Console.WriteLine("After XOR operation:");
for (int i = 0; i < ba4.Count; i++)
{
Console.Write("{0 , -6}", ba4[i]);
}
Console.WriteLine();
}
public override void ReadGroupCodes()
{
BitArray flags;
BitArray comparer;
bool processingVertices;
CEntityVertex vertex;
VertexList = new ArrayList();
processingVertices = false;
vertex = null;
foreach (CGroupCode gc in GroupCodeList)
{
if (gc.Code == 0)
{
if (gc.Value.Trim().ToUpper() == "VERTEX")
{
processingVertices = true;
if (vertex != null)
{
vertex.ReadGroupCodes();
VertexList.Add(vertex);
}
vertex = new CEntityVertex();
vertex.EntityName = "VERTEX";
vertex.LayerName = LayerName;
}
else if (gc.Value.Trim().ToUpper() == "SEQEND")
{
processingVertices = false;
if (vertex != null)
{
vertex.ReadGroupCodes();
VertexList.Add(vertex);
}
}
}
else if (gc.Code == 30 && processingVertices == false)
{
Elevation = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 40 && processingVertices == false)
{
DefaultStartingWidth = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 41 && processingVertices == false)
{
DefaultEndingWidth = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 70 && processingVertices == false)
{
flags = new BitArray(new int[] { CGlobals.ConvertToInt(gc.Value.Trim()) });
comparer = new BitArray(new int[] { 1 });
IsClosedPolyline = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 2 });
HasCurveFitVertices = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 4 });
HasSplineFitVertices = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 8 });
Is3DPolyline = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 16 });
Is3DMesh = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 32 });
MeshClosedInTheNDirection = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 64 });
IsPolyfaceMesh = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 128 });
ContinuousLineType = flags.And(comparer)[0];
}
else if (gc.Code == 71 && processingVertices == false)
{
PolygonMeshMVertexCount = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 72 && processingVertices == false)
{
PolygonMeshNVertexCount = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 73 && processingVertices == false)
{
SmoothSurfaceMDensity = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 74 && processingVertices == false)
{
SmoothSurfaceNDensity = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if (gc.Code == 75 && processingVertices == false)
{
if (CGlobals.ConvertToInt(gc.Value.Trim()) == 0)
{
NoSmoothSurfaceFitted = true;
}
else if (CGlobals.ConvertToInt(gc.Value.Trim()) == 5)
{
QuadraticBSplineSurface = true;
}
else if (CGlobals.ConvertToInt(gc.Value.Trim()) == 6)
{
CubicBSplineSurface = true;
}
else if (CGlobals.ConvertToInt(gc.Value.Trim()) == 8)
{
BezierSurface = true;
}
}
else
{
if (processingVertices && vertex != null)
{
if (gc.Code == 5)
{
// Handle
vertex.Handle = gc.Value.Trim();
}
else if (gc.Code == 6)
{
// Line Type
vertex.LineType = gc.Value.Trim();
}
else if (gc.Code == 8)
{
// Layer Name
vertex.LayerName = gc.Value.Trim();
}
else
{
vertex.GroupCodeList.Add(gc);
}
}
}
}
}
public static BitArray And(BitArray X, BitArray Y)
{
BitArray n = X.And(Y);
return(n);
}
public override void ReadGroupCodes()
{
BitArray flags;
BitArray comparer;
foreach(CGroupCode gc in GroupCodeList)
{
if(gc.Code == 10)
{
X0 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 20)
{
Y0 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 30)
{
Z0 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 11)
{
X1 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 21)
{
Y1 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 31)
{
Z1 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 12)
{
X2 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 22)
{
Y2 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 32)
{
Z2 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 13)
{
X3 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 23)
{
Y3 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 33)
{
Z3 = CGlobals.ConvertToDouble(gc.Value.Trim());
}
else if(gc.Code == 70)
{
flags = new BitArray(new int[] { CGlobals.ConvertToInt(gc.Value.Trim()) });
comparer = new BitArray(new int[] { 1 });
Edge1Invisible = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 2 });
Edge2Invisible = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 4 });
Edge3Invisible = flags.And(comparer)[0];
comparer = new BitArray(new int[] { 8 });
Edge4Invisible = flags.And(comparer)[0];
}
}
}
static void Main(string[] args)
{
#region Khai báo và khởi tạo BitArray
/*
* Khởi tạo 1 BitArray có 10 phần tử
* Mỗi phần tử có giá trị mặc định 0 (false)
*/
BitArray MyBA = new BitArray(10);
/*
* Khởi tạo 1 BitArray có 10 phần tử
* Mỗi phần tử có giá trị mặc định 0 (false)
*/
BitArray MyBA2 = new BitArray(10, true);
// Khởi tạo 1 BitArray từ 1 mảng bool có sẵn
bool[] MyBools = new bool[5] {
true, false, true, true, false
};
BitArray MyBA3 = new BitArray(MyBools); // 1 0 1 1 0
// Khởi tạo 1 BitArray từ 1 mảng byte có sẵn
byte[] MyBytes = new byte[5] {
1, 2, 3, 4, 5
};
BitArray MyBA4 = new BitArray(MyBytes);
// Kiểm thử. Uncomment để xem kết quả
WriteLine(" So bit cua BitArray la {0}", MyBA4.Length);
PrintBit(MyBA4, 8);
// Khởi tạo 1 BitArray từ 1 mảng int có sẵn
int[] MyInts = new int[5] {
1, 2, 3, 4, 5
};
BitArray MyBA5 = new BitArray(MyInts);
// Kiểm thử. Uncomment để xem kết quả
// WriteLine(" So bit cua BitArray la {0}", MyBA5.Length);
// PrintBit(MyBA5, 32);
#endregion
#region Ví dụ và sử dụng BitArray
// Khởi tạo 1 BitArray từ mảng bool có sẵn
bool[] MyBools2 = new bool[5] {
true, false, true, true, false
};
BitArray MyBA6 = new BitArray(MyBools2);
// Khởi tạo 1 BitArray có 2 phần tử và có giá trị mặc định là 1 (true)
bool[] MyBool3 = new bool[] { false, true, true, false, false };
BitArray MyBA7 = new BitArray(MyBool3);
Write(" Gia tri cua MyBA6: ");
PrintBit(MyBA6, 5);
Write(" Gia tri cua MyBA7: ");
PrintBit(MyBA7, 5);
WriteLine(" Thuc hien cac phep toan AND, OR, NOT, XOR tren MyBA6, va MyBA7: ");
// Thực hiện sao chép giá trị của MyBA6 ra để không làm thay đổi nó
BitArray AndBit = MyBA6.Clone() as BitArray;
AndBit.And(MyBA7);
Write(" Ket qua cua phep toan AND: ");
PrintBit(AndBit, 5);
BitArray OrBit = MyBA6.Clone() as BitArray;
OrBit.Or(MyBA7);
Write(" Ket qua cua phep toan AND: ");
PrintBit(OrBit, 5);
BitArray NotBit = MyBA6.Clone() as BitArray;
NotBit.Not();
Write(" Ket qua cua phep toan AND: ");
PrintBit(NotBit, 5);
BitArray XorBit = MyBA6.Clone() as BitArray;
XorBit.Xor(MyBA7);
Write(" Ket qua cua phep toan AND: ");
PrintBit(XorBit, 5);
#endregion
}
public virtual bool runTest()
{
Console.Out.WriteLine( "Plain\\System_NewCollections\\BitArray\\Co1550And.cs runTest() started." );
int iCountErrors = 0;
int iCountTestcases = 0;
BitArray ba2 = null;
BitArray ba3 = null;
BitArray ba4 = null;
ba2 = new BitArray( 6 ,false );
ba3 = new BitArray( 6 ,false );
ba2.Set( 0 ,true );
ba2.Set( 1 ,true );
ba3.Set( 1 ,true );
ba3.Set( 2 ,true );
ba4 = ba2.And( ba3 );
++iCountTestcases;
if ( ba4.Get( 0 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_09pv (Co1550And)" );
Console.Error.WriteLine( "EXTENDEDINFO: 1 & 0 (E_09pv ,Co1550And)" );
}
++iCountTestcases;
if ( ! ba4.Get( 1 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_96hf (Co1550And)" );
}
++iCountTestcases;
if ( ba4.Get( 2 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_84si (Co1550And)" );
}
++iCountTestcases;
if ( ba4.Get( 4 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_79kn (Co1550And)" );
}
ba2 = new BitArray( 0x1000F ,false );
ba3 = new BitArray( 0x1000F ,false );
ba2.Set( 0x10000 ,true );
ba2.Set( 0x10001 ,true );
ba3.Set( 0x10001 ,true );
ba3.Set( 0x10002 ,true );
ba4 = ba2.And( ba3 );
++iCountTestcases;
if ( ba4.Get( 0x10000 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_61ah (Co1550And)" );
}
++iCountTestcases;
if ( ! ba4.Get( 0x10001 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_52xd (Co1550And)" );
}
++iCountTestcases;
if ( ba4.Get( 0x10002 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_47op (Co1550And)" );
}
++iCountTestcases;
if ( ba4.Get( 0x10004 ) )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_54ja (Co1550And)" );
}
try
{
BitArray b1 = new BitArray( 0 );
BitArray b2 = new BitArray( 0 );
b1.And( b2 );
}
catch ( Exception exc )
{
++iCountErrors;
Console.WriteLine( "Err_001, Exception was not expected " + exc );
}
ba2 = new BitArray( 11 ,false );
ba3 = new BitArray( 6 ,false );
try
{
++iCountTestcases;
ba4 = ba2.And( ba3 );
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_66vc (Co1550And)" );
}
catch ( ArgumentException ) {}
catch ( Exception )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_58jq (Co1550And)" );
}
ba2 = new BitArray( 6 ,false );
ba3 = new BitArray( 11 ,false );
try
{
++iCountTestcases;
ba4 = ba2.And( ba3 );
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_432k (Co1550And)" );
}
catch ( ArgumentException ) {}
catch ( Exception )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_452a (Co1550And)" );
}
ba2 = new BitArray( 6 ,false );
ba3 = null;
try
{
++iCountTestcases;
ba4 = ba2.And( ba3 );
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_72dg (Co1550And)" );
}
catch ( ArgumentNullException ) {}
catch ( Exception )
{
++iCountErrors;
Console.Error.WriteLine( "POINTTOBREAK: find error E_93kx (Co1550And)" );
}
if ( iCountErrors == 0 )
{
Console.Error.Write( "BitArray\\Co1550And.cs: paSs. iCountTestcases==" );
Console.Error.WriteLine( iCountTestcases );
return true;
}
else
{
Console.Error.Write( "Co1550And.cs iCountErrors==" );
Console.Error.WriteLine( iCountErrors );
Console.Error.WriteLine( "PATHTOSOURCE: BitArray\\Co1550And.cs FAiL !" );
return false;
}
}
static void Main(string[] args)
{
List <int> ilist = new List <int>();
ilist.Add(10);
ilist.Add(7);
ilist.Add(15);
ilist.Add(3);
foreach (int i in ilist)
{
Console.WriteLine(i);
}
ilist.Sort();
Console.WriteLine("Sorted List:");
foreach (int i in ilist)
{
Console.WriteLine(i);
}
LinkedList <int> llist = new LinkedList <int>();
llist.AddLast(10);
llist.AddLast(15);
llist.AddLast(20);
LinkedListNode <int> middle = llist.Find(15);
llist.AddAfter(middle, 18);
foreach (int i in llist)
{
Console.WriteLine(i);
}
Console.WriteLine("Queue:");
Queue <int> q1 = new Queue <int>();
q1.Enqueue(1);
q1.Enqueue(2);
q1.Enqueue(3);
while (q1.Count > 0)
{
Console.WriteLine(q1.Dequeue());
}
Console.WriteLine("Stack");
Stack <int> s1 = new Stack <int>();
s1.Push(1);
s1.Push(2);
s1.Push(3);
while (s1.Count > 0)
{
Console.WriteLine(s1.Pop());
}
BitArray ba = new BitArray(5, true);
ba.Set(2, false);
foreach (bool b in ba)
{
Console.WriteLine(b);
}
BitArray ba2 = new BitArray(5, true);
ba2.Set(0, false);
ba2.Set(1, false);
Console.WriteLine("And BitArray:");
ba.And(ba2);
foreach (bool b in ba)
{
Console.WriteLine(b);
}
HashSet <string> hs = new HashSet <string>();
hs.Add("String1");
hs.Add("String2");
hs.Add("String3");
hs.Add("String4");
hs.Add("String5");
hs.Add("String5");
foreach (string s in hs)
{
Console.WriteLine(s);
}
}
public void Update()
{
#if DEBUG
var watch = System.Diagnostics.Stopwatch.StartNew();
#endif
Map map = Find.Maps.Find(x => x.uniqueID == areaExtID.MapID);
if (map == null)
{
return;
}
this.areaManager = map.areaManager;
var innerAreas = InnerAreas;
BoolGrid innerGrid = (BoolGrid)FieldInfos.innerGrid.GetValue(this);
bool[] arr = (bool[])FieldInfos.boolGridArr.GetValue(innerGrid);
BitArray arrBA = new BitArray(arr);
if (innerAreas.Count > 0 && innerAreas.Any(x => x.Value == AreaExtOperator.Inclusion))
{
arrBA.SetAll(false);
}
else
{
arrBA.SetAll(true);
}
var areaNameBuilder = new StringBuilder();
for (int i = 0; i < innerAreas.Count; ++i)
{
var kv = innerAreas[i];
Area area = kv.Key;
AreaExtOperator op = kv.Value;
BitArray targetArrBA = GetAreaBitArray(area);
if (op == AreaExtOperator.Inclusion)
{
arrBA = arrBA.Or(targetArrBA);
if (i > 0)
{
areaNameBuilder.Append("+");
}
}
else if (op == AreaExtOperator.Exclusion)
{
arrBA = arrBA.And(targetArrBA.Not());
areaNameBuilder.Append("-");
}
areaNameBuilder.Append(area.Label);
}
arrBA.CopyTo(arr, 0);
FieldInfos.boolGridArr.SetValue(innerGrid, arr);
FieldInfos.boolGridTrueCount.SetValue(innerGrid, arr.Count(x => x));
cachedLabel = areaNameBuilder.ToString();
if (innerAreas.Count == 1)
{
cachedColor = innerAreas[0].Key.Color;
}
else
{
cachedColor = Color.black;
}
initialized = true;
drawer.dirty = true;
#if DEBUG
watch.Stop();
Log.Message(string.Format("Update elapsed : {0}", watch.ElapsedMilliseconds));
#endif
}
public void AndWith(IBitset otherSet)
{
_Array = _Array.And(((UncompressedBitArray)otherSet)._Array);
}
// <summary>
// Given discriminator values (ordinally aligned with DiscriminatorColumns), determines
// the entity type to return. Throws a CommandExecutionException if the type is ambiguous.
// </summary>
internal EntityType Discriminate(object[] discriminatorValues, int resultSetIndex)
{
var resultMapping = GetResultMapping(resultSetIndex);
Debug.Assert(resultMapping != null);
// initialize matching types bit map
var typeCandidates = new BitArray(resultMapping.MappedEntityTypes.Count, true);
foreach (var typeMapping in resultMapping.NormalizedEntityTypeMappings)
{
// check if this type mapping is matched
var matches = true;
var columnConditions = typeMapping.ColumnConditions;
for (var i = 0; i < columnConditions.Count; i++)
{
if (null != columnConditions[i]
&& // this discriminator doesn't matter for the given condition
!columnConditions[i].ColumnValueMatchesCondition(discriminatorValues[i]))
{
matches = false;
break;
}
}
if (matches)
{
// if the type condition is met, narrow the set of type candidates
typeCandidates = typeCandidates.And(typeMapping.ImpliedEntityTypes);
}
else
{
// if the type condition fails, all implied types are eliminated
// (the type mapping fragment is a co-implication, so a type is no longer
// a candidate if any condition referring to it is false)
typeCandidates = typeCandidates.And(typeMapping.ComplementImpliedEntityTypes);
}
}
// find matching type condition
EntityType entityType = null;
for (var i = 0; i < typeCandidates.Length; i++)
{
if (typeCandidates[i])
{
if (null != entityType)
{
throw new EntityCommandExecutionException(Strings.ADP_InvalidDataReaderUnableToDetermineType);
}
entityType = resultMapping.MappedEntityTypes[i];
}
}
// if there is no match, raise an exception
if (null == entityType)
{
throw new EntityCommandExecutionException(Strings.ADP_InvalidDataReaderUnableToDetermineType);
}
return(entityType);
}
// returns a bitboard of a pump station that exists on the specified coordinates,
// or return empty if no pump station exists on the specified coordinates
public static BitArray GetPumpStation(BitArray pumpStations, int x, int y)
{
// check to see if specified unit is on one of our pump stations
BitArray test = new BitArray(length, false).Or(pumpStations);
test.And(position[x][y]);
if (Equal(test, empty))
{
return empty;
}
// create bitboard representing pump station the unit is standing on
BitArray pumpStation = new BitArray(length, false).Or(position[x][y]);
if (x - 1 >= 0)
{
pumpStation.Or(position[x - 1][y]);
if (y - 1 >= 0)
{
pumpStation.Or(position[x - 1][y - 1]);
}
if (y + 1 < height)
{
pumpStation.Or(position[x - 1][y + 1]);
}
}
if (x + 1 < width)
{
pumpStation.Or(position[x + 1][y]);
if (y - 1 >= 0)
{
pumpStation.Or(position[x + 1][y - 1]);
}
if (y + 1 < height)
{
pumpStation.Or(position[x + 1][y + 1]);
}
}
if (y - 1 >= 0)
{
pumpStation.Or(position[x][y - 1]);
}
if (y + 1 < height)
{
pumpStation.Or(position[x][y + 1]);
}
return pumpStation.And(pumpStations);
}