static public int Not(IntPtr l) { try { System.Collections.BitArray self = (System.Collections.BitArray)checkSelf(l); var ret = self.Not(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
private BitArray feistelFunction(BitArray keyBits, BitArray Bittext_16) { BitArray afterParity = Bittext_16; if (checkParity(keyBits)) //true if parity is even { afterParity = Bittext_16.Not(); //Console.WriteLine("Right after negating : " + BitOperations.getBinaryString(afterParity)); } //Console.WriteLine("Keybits for xoring : " + BitOperations.getBinaryString(keyBits)); var feistelOutput = keyBits.Xor(new BitArray(afterParity)); //Console.WriteLine("right 16 bits after fiestal function : " + BitOperations.getBinaryString(a)); return feistelOutput; }
public void BitArrayToText() { var bitArray = new BitArray(32); var bitString = bitArray.ToText(); Assert.AreEqual(32, bitString.Length); Assert.IsFalse(bitString.Contains("1")); Assert.IsTrue(bitString.All(c => c == '0')); bitString = bitArray.Not().ToText(); Assert.AreEqual(32, bitString.Length); Assert.IsFalse(bitString.Contains("0")); Assert.IsTrue(bitString.All(c => c == '1')); }
public void BitArrayToBytes() { var bitArray = new BitArray(32); var bytes = bitArray.ToBytes(); Assert.AreEqual(32 / BitTool.ByteLength, bytes.Length); Assert.IsTrue(bytes.All(b => b == 0x00)); Assert.IsTrue(bytes.GetHexStringFromBytes().All(c => c == '0')); bytes = bitArray.Not().ToBytes(); Assert.IsTrue(bytes.GetHexStringFromBytes().All(c => c == 'F')); // Console.WriteLine(bytes.GetHexStringFromBytes()); }
public static void BitArray_NotTest() { // [] Standard cases BitArray ba2 = null; BitArray ba4 = null; ba2 = new BitArray(6, false); ba2.Set(0, true); ba2.Set(1, true); ba4 = ba2.Not(); for (int i = 0; i < ba4.Length; i++) { if (i <= 1) Assert.False(ba4.Get(i)); //"Err_2! ba4.Get(" + i + ") should be false" else Assert.True(ba4.Get(i)); //"Err_3! ba4.Get(" + i + ") should be true" } // [] Size stress cases. ba2 = new BitArray(0x1000F, false); ba2.Set(0, true); ba2.Set(1, true); ba2.Set(0x10000, true); ba2.Set(0x10001, true); ba4 = ba2.Not(); Assert.False(ba4.Get(1)); //"Err_4! ba4.Get(1) should be false" Assert.True(ba4.Get(2)); //"Err_5! ba4.Get(2) should be true" for (int i = 0x10000; i < ba2.Length; i++) { if (i <= 0x10001) Assert.False(ba4.Get(i)); //"Err_6! ba4.Get(" + i + ") should be false" else Assert.True(ba4.Get(i)); //"Err_7! ba4.Get(" + i + ") should be true" } }
static void BitArrayDemo() { var bits1 = new BitArray(8); bits1.SetAll(true); bits1.Set(1, false); bits1[5] = false; bits1[7] = false; Console.Write("initialized: "); DisplayBits(bits1); Console.WriteLine(); DisplayBits(bits1); bits1.Not(); Console.Write(" not "); DisplayBits(bits1); Console.WriteLine(); var bits2 = new BitArray(bits1); bits2[0] = true; bits2[1] = false; bits2[4] = true; DisplayBits(bits1); Console.Write(" or "); DisplayBits(bits2); Console.Write(" : "); bits1.Or(bits2); DisplayBits(bits1); Console.WriteLine(); DisplayBits(bits2); Console.Write(" and "); DisplayBits(bits1); Console.Write(" : "); bits2.And(bits1); DisplayBits(bits2); Console.WriteLine(); DisplayBits(bits1); Console.Write(" xor "); DisplayBits(bits2); bits1.Xor(bits2); Console.Write(" : "); DisplayBits(bits1); Console.WriteLine(); }
/// <summary> /// Takes bits array of positive number and make this number negative. /// First invert input bit array, then adds 1. That makes positive number negative. /// </summary> /// <param name="arr">Bit array of positive number</param> private void Negative(BitArray arr) { arr.Not(); bool overflow = false; for (int i = 0; i < arr.Length; i++) if (i == 0) { if (arr[0] & true) overflow = true; arr[0] ^= true; } else if (overflow) { if (!(arr[i] & true)) overflow = false; arr[i] ^= true; } else break; }
public BitArray/*!*/ Parse() { _pos = 0; BitArray result = new BitArray(256); if (_range.Length == 0) { return result; } bool negate = false; if (_range.GetChar(0) == '^') { // Special case of ^ if (_range.Length == 1) { result.Set('^', true); return result; } negate = true; _pos = 1; result.Not(); } int c; while ((c = NextToken()) != -1) { if (_rangeStarted) { // _startRange - c. ignore ranges which are the reverse sequence if (_startRange <= c) { for (int i = _startRange; i <= c; ++i) result.Set(i, !negate); } _rangeStarted = false; } else { int p = PeekChar(); if (p == '-') { // z- is treated as a literal 'z', '-' if (_pos == _range.Length - 1) { result.Set(c, !negate); result.Set('-', !negate); break; } _startRange = c; if (_rangeStarted) { result.Set('-', !negate); _rangeStarted = false; } else { _rangeStarted = true; } _pos++; // consume - } else { result.Set(c, !negate); } } } return result; }
public void Minus(HasseFingerprint FP) { // do this AND (NOT that) BitArray fpx= new BitArray (FP.fp); fpx.Not (); fp.And(fpx); this.bitCount = this.CountBits(); }
// TODO: refactor this and Parse() public MutableString/*!*/ ParseSequence() { _pos = 0; MutableString result = MutableString.CreateBinary(); if (_range.Length == 0) { return result; } bool negate = false; if (_range.GetChar(0) == '^') { // Special case of ^ if (_range.Length == 1) { result.Append('^'); return result; } negate = true; _pos = 1; } BitArray array = new BitArray(256); array.Not(); int c; while ((c = NextToken()) != -1) { if (_rangeStarted) { // _startRange - c. ignore ranges which are the reverse sequence if (_startRange <= c) { for (int i = _startRange; i <= c; ++i) { if (negate) { array.Set(i, false); } else { result.Append((byte)i); } } } _rangeStarted = false; } else { int p = PeekChar(); if (p == '-') { // z- is treated as a literal 'z', '-' if (_pos == _range.Length - 1) { if (negate) { array.Set(c, false); array.Set('-', false); } else { result.Append((byte)c); result.Append('-'); } break; } _startRange = c; if (_rangeStarted) { if (negate) { array.Set('-', false); } else { result.Append('-'); } _rangeStarted = false; } else { _rangeStarted = true; } _pos++; // consume - } else { if (negate) { array.Set(c, false); } else { result.Append((byte)c); } } } } if (negate) { for (int i = 0; i < 256; i++) { if (array.Get(i)) { result.Append((byte)i); } } } return result; }
/// <summary> /// Add a transition from NState "this" /// to NState "nxt", for each character /// value in the leaf range list. /// If the characters are packed, transform /// from character ordinal to equivalence class /// ordinal. /// </summary> /// <param name="leaf">The regex leaf node</param> /// <param name="nxt">The destination state</param> public void AddClsTrans(Leaf leaf, NState nxt) { if (myNfaInst.parent.task.CaseAgnostic) { leaf.rangeLit.list = leaf.rangeLit.list.MakeCaseAgnosticList(); leaf.rangeLit.list.Canonicalize(); } BitArray cls = new BitArray(myNfaInst.MaxSym); if (myNfaInst.Pack) { foreach (int ord in leaf.rangeLit.equivClasses) cls[ord] = true; } else { foreach (CharRange rng in leaf.rangeLit.list.Ranges) for (int i = rng.minChr; i <= rng.maxChr; i++) cls[i] = true; if (leaf.rangeLit.list.IsInverted) cls = cls.Not(); } AddClsTrans(cls, nxt); }
/// <summary> /// Add a transition from NState "this" /// to NState "nxt", for each character /// value in the leaf range list. /// If the characters are packed, transform /// from character ordinal to equivalence class /// ordinal. /// </summary> /// <param name="leaf">The regex leaf node</param> /// <param name="nxt">The destination state</param> public void AddClsTrans(Leaf leaf, NState nxt) { BitArray cls = new BitArray(myNfaInst.MaxSym); if (myNfaInst.Pack) { foreach (int ord in leaf.rangeLit.equivClasses) cls[ord] = true; } else { foreach (CharRange rng in leaf.rangeLit.list.Ranges) for (int i = rng.minChr; i <= rng.maxChr; i++) cls[i] = true; if (leaf.rangeLit.list.IsInverted) cls = cls.Not(); } AddClsTrans(cls, nxt); }
public static BitArray AndNot(BitArray b1, BitArray b2) { if (b1.Length > b2.Length) { b2.Length = b1.Length; } else if (b2.Length > b1.Length) { b1.Length = b2.Length; } b1.And(b2.Not()); return b1; }
/// <summary> /// Gets one's complement of a signed integer /// </summary> /// <param name="number">signed integer (value) </param> /// <param name="index">number of bits in the signed int</param> /// <returns>one's complement of a signed int</returns> internal static int OnesComplement(int number, int bits) { // zero count offset bits--; // convert to bit array. BitArray compArray = new BitArray(BitConverter.GetBytes(number)); // a true most significant bit (MSB) indicates a negative // nubmer and all bits must be flipped (~). if (compArray.Get(bits)) { // invert all bits (complement) compArray.Not(); // set all unused bits to false. for (int i = bits; i < compArray.Length; i++) { compArray[i] = false; } // convert bitarray to integer, using copyto. int[] retunArray = new int[1]; compArray.CopyTo(retunArray, 0); // return negative complement return -(retunArray[0]); } // positive complement = binary representation return number; }
public static void Main() { Cons.WriteLine($"Chapter 10 - Collections..."); //Play._Time(1); //Play._Time(2); //Collection Initializers var intList = new List <int>() { 1, 2, 3, 4, 5 }; //Racers Racer GHill = new Racer(2, "Graham", "Hill", "UK", 10); Racer DHill = new Racer(7, "Dameon", "Hill", "UK", 14); var racers = new List <Racer>(10) { GHill, DHill }; Cons.WriteLine($"{racers.Count} racers so far."); racers.Add(new Racer(24, "Michael", "Schumacher", "Germany", 91)); racers.Insert(0, new Racer(22, "Ayrton", "Senna", "Brazil", 41)); //Accessing elements var a1 = racers[0]; Cons.WriteLine("Print list with a foreach loop........................................."); foreach (var r in racers) { Cons.WriteLine(r.ToString("N", null)); } //Delagates again! Cons.WriteLine("Now using a delegate........................................."); racers.ForEach(Cons.WriteLine); Cons.WriteLine("Now using lambda to format........................................."); racers.ForEach(r => Cons.WriteLine($"{r:w}")); Racer R1 = new Racer(22, "Ayrton", "Senna", "Brazil", 41); if (!racers.Remove(R1)) { Cons.WriteLine($"Racer {R1.Id} not found to remove."); } R1 = DHill; if (!racers.Remove(R1)) { Cons.WriteLine($"Racer {DHill.Id} not found to remove."); } racers.Add(R1); //Using Find Predicate //int i2 = racers.FindIndex(new FindCountry("Finland").FindCountryPredicate); This works but has a bugget, not my code! int i3 = racers.FindIndex(r => r.Country == "UK"); //Sane as line above and more likely to be used... i3 = racers.FindLastIndex(r => r.Country == "UK"); //Sane as line above and more likely to be used... var R2 = racers.FindLast(r => r.LastName == "Louder"); var someWins = racers.FindAll(r => r.Wins < 20); someWins.Sort(); var bigWiners = racers.FindAll(r => r.Wins > 20); bigWiners.Sort(); racers.Sort(new RacerComp(RacerComp.CompareType.LastName)); racers.Sort(new RacerComp(RacerComp.CompareType.Country)); //Sort using delagte and Lambda expression. racers.Sort((r1, r2) => r2.Wins.CompareTo(r1.Wins)); racers.Reverse(); //Type Conversion... var rPeople = racers.ConvertAll <Person>(r => new Person(r.FirstName + ',' + r.LastName)); //Read-Only Collections var roRacers = racers.AsReadOnly(); //Queues var dm = new DocsManager(); ProcessDocs.Start(dm); //Create docs and add too dm for (int i = 0; i < 100; i++) { var doc = new Doc("Doc" + i.ToString(), "AID" + new Random().Next(20).ToString()); dm.AddDoc(doc); Console.WriteLine($"Added Document: {doc.Title} by {doc.Auther} to queue."); Thread.Sleep(new Random().Next(20)); } Thread.Sleep(2000); ProcessDocs.Stop(); //Stacks Quick one... var lets = new Stack <char>(); lets.Push('A'); lets.Push('B'); lets.Push('C'); foreach (var l in lets) { Cons.Write(l); } Cons.WriteLine(); while (lets.Count > 0) { Cons.Write(lets.Pop()); } Cons.WriteLine($"Next..."); //Linked Lists... var pDM = new PDocManager(); pDM.AddPDoc(new PDoc("Adoc", "AAAdams", 4)); pDM.AddPDoc(new PDoc("Bdoc", "BBabs", 8)); pDM.AddPDoc(new PDoc("Cdoc", "CCock", 4)); pDM.AddPDoc(new PDoc("Ddoc", "AAAdams", 8)); pDM.AddPDoc(new PDoc("Edoc", "CCock", 8)); pDM.DisplayAllNodes(); //Simple Sorted List var boots = new SortedList <int, string>(); boots.Add(18, "Knee High"); boots.Add(27, "Thigh Length"); boots[12] = "Calfe"; boots[6] = "Ankle"; foreach (var b in boots) { Cons.WriteLine($"{b.Key}, {b.Value}"); } boots[27] = "Thigh High"; foreach (var b in boots) { Cons.WriteLine($"{b.Key}, {b.Value}"); } //What Next....for DCoates var employees = new Dictionary <EmployeeId, DicEmployee>(); var idCat = new EmployeeId("A000001"); var eCat = new DicEmployee(idCat, "Cat", 100000.00m); employees.Add(idCat, eCat); var idAnt = new EmployeeId("A012345"); var eAnt = new DicEmployee(idAnt, "Ant", 23000.00m); employees.Add(idAnt, eAnt); var idBee = new EmployeeId("B000001"); var eBee = new DicEmployee(idBee, "Bee", 40000.00m); employees.Add(idBee, eBee); var idDog = new EmployeeId("A000002"); var eDog = new DicEmployee(idDog, "Dog", 10000.00m); employees.Add(idDog, eDog); foreach (var e in employees) { Cons.WriteLine(e.ToString()); } while (true) { Cons.Write("Enter am Empolyee Id: (X to exit)>"); var uIn = Cons.ReadLine(); if (uIn.ToLower() == "x") { break; } EmployeeId eId; try { eId = new EmployeeId(uIn); DicEmployee dEmp; if (!employees.TryGetValue(eId, out dEmp)) { Cons.WriteLine($"Employee with {eId} does not exist."); } else { Cons.WriteLine(dEmp); } } catch (EmployeeIdException ee) { Cons.WriteLine(ee.Message); } } //Lookups from System.core //Use the racers list from above var lookupRacers = racers.ToLookup(r => r.Country); foreach (var r in lookupRacers["UK"]) { Cons.WriteLine($"name:{r.LastName}, {r.FirstName}"); } //Nice but not sorted! //Sorted Dics.... //Simple Sorted List var sdBoots = new SortedDictionary <int, string> { { 18, "Knee High" }, { 27, "Thigh Length" } }; sdBoots[12] = "Calfe"; sdBoots[6] = "Ankle"; foreach (var b in sdBoots) { Cons.WriteLine($"{b.Key}, {b.Value}"); } //Sets... var allTeams = new HashSet <string>() { "Ferrari", "Lotus", "McLaren", "Honda", "BRM", "Aston Martin", "Red Bull", "Force India", "Sauber", "Williams" }; var coTeams = new HashSet <string>() { "Ferrari", "Lotus", "McLaren", "Honda" }; var oldTeams = new HashSet <string>() { "Ferrari", "Lotus", "BRM", "Aston Martin" }; var newTeams = new HashSet <string>() { "Red Bull", "Force India", "Sauber" }; var res = coTeams.Add("Williams"); res = coTeams.Add("Williams"); res = coTeams.IsSubsetOf(allTeams); res = allTeams.IsSupersetOf(coTeams); res = oldTeams.Overlaps(coTeams); res = newTeams.Overlaps(coTeams); var allTeams2 = new SortedSet <string>(coTeams); allTeams2.UnionWith(oldTeams); allTeams2.UnionWith(newTeams); res = allTeams2.SetEquals(allTeams); var tTeams = new SortedSet <string>(allTeams); tTeams.SymmetricExceptWith(oldTeams); var yTeams = new SortedSet <string>(allTeams); var yI = new SortedSet <string>(yTeams.Intersect(oldTeams)); //Observable Collections Cons.Clear(); Cons.WriteLine("Observable Collections...."); var data = new ObservableCollection <string>(); data.CollectionChanged += Data_CollectionChanged; data.Add("First"); data.Add("Second"); data.Insert(1, "Three"); data.Remove("Three"); //Bits and bobs.... Cons.WriteLine("Bits and Bobs...."); var bitsA = new Col.BitArray(8); bitsA.SetAll(true); bitsA.Set(1, false); DisplayBits(bitsA); Cons.WriteLine(); bitsA.Not(); DisplayBits(bitsA); byte[] aI = { 22 }; var bitsB = new Col.BitArray(aI); DisplayBits(bitsB); bitsA.Or(bitsB); DisplayBits(bitsA); //BitVector32 Struct var vBits = new Col.Specialized.BitVector32(); int m1 = BitVector32.CreateMask(); int m2 = BitVector32.CreateMask(m1); int m3 = BitVector32.CreateMask(m2); int m4 = BitVector32.CreateMask(m3); int m5 = BitVector32.CreateMask(128); vBits[m1] = true; vBits[m3] = true; vBits[m4] = true; vBits[m5] = true; Cons.WriteLine(vBits); int rec = 0x88abcde; var vBitRSet = new BitVector32(rec); Cons.WriteLine(vBitRSet); //Immutable Collections ImmutabeThings.ImmutableTing1(); Cons.ReadKey(); }
public Genome MakeChild(Genome other, BitArray mask) { BitArray leftCopy = new BitArray(this.genome); BitArray rightCopy = new BitArray(other.genome); BitArray maskCopy = new BitArray(mask); leftCopy.And(maskCopy); rightCopy.And(maskCopy.Not()); //BitArray temp2 = new BitArray(right.And(mask.Not())); return new Genome(leftCopy.Or(rightCopy)); }
static void Main(string[] args) { // Creates an initializes several BitArrays. BitArray myBA1 = new BitArray(5); BitArray myBA2 = new BitArray(5, false); byte[] myBytes = new byte[5] { 1, 2, 3, 4, 5 }; BitArray myBA3 = new BitArray(myBytes); bool[] myBools = new bool[5] { true, false, true, true, false }; BitArray myBA4 = new BitArray(myBools); int[] myInts = new int[5] { 6, 7, 8, 9, 10 }; BitArray myBA5 = new BitArray(myInts); // Displays the properties and values of the BitArrays. Console.WriteLine("myBA1"); Console.WriteLine(" Count: {0}", myBA1.Count); Console.WriteLine(" Length: {0}", myBA1.Length); Console.WriteLine(" Values:"); PrintValues(myBA1, 8); Console.WriteLine("myBA2"); Console.WriteLine(" Count: {0}", myBA2.Count); Console.WriteLine(" Length: {0}", myBA2.Length); Console.WriteLine(" Values:"); PrintValues(myBA2, 8); Console.WriteLine("myBA3"); Console.WriteLine(" Count: {0}", myBA3.Count); Console.WriteLine(" Length: {0}", myBA3.Length); Console.WriteLine(" Values:"); PrintValues(myBA3, 8); Console.WriteLine("myBA4"); Console.WriteLine(" Count: {0}", myBA4.Count); Console.WriteLine(" Length: {0}", myBA4.Length); Console.WriteLine(" Values:"); PrintValues(myBA4, 8); Console.WriteLine("myBA5"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA5, 8); int[] myAntiInts = new int[5] { -1, -1, -1, -1, -1 }; BitArray myBA6 = new BitArray(myAntiInts); Console.WriteLine("myBA6"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA6, 8); Console.WriteLine("\nXORing BA5 with BA6...\n"); BitArray myBA7 = myBA5.Xor(myBA6); Console.WriteLine("myBA7"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA7, 8); Console.WriteLine("myBA5"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA5, 8); Console.WriteLine("myBA6"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA6, 8); Console.WriteLine("\nNot on myBA5:\n"); myBA5.Not(); Console.WriteLine("myBA5"); Console.WriteLine(" Count: {0}", myBA5.Count); Console.WriteLine(" Length: {0}", myBA5.Length); Console.WriteLine(" Values:"); PrintValues(myBA5, 8); }