//Runs the algoritm for number of iterations public override void Run(Configuration config) { log = new RandomLogSpecification(data.DataFileName, config.RandomSeed, config.NumberOfRuns, config.PenaltyCoefficient); solution = new SolutionSpecification(); BitArray routerswitches = new BitArray((int)data.RouterCount); double highestfitness = 0.0; BitArray best = new BitArray((int)data.RouterCount); for(int i = 0; i < config.NumberOfRuns; i++) { routerswitches = new BitArray((int)data.RouterCount); int numbertoswitch = randomgenerator.Next((int)data.RouterCount); for(int j = 0; j < numbertoswitch; j++) { int switching; while(routerswitches.Get(switching = randomgenerator.Next((int)data.RouterCount)) == true); routerswitches.Set(switching, true); } double fitness = FitnessEvaluation(data.NetworkPaths, routerswitches, numbertoswitch, config.PenaltyCoefficient); if(fitness > highestfitness) { ((RandomLogSpecification)log).AddEvaluation(i, fitness); highestfitness = fitness; best = (BitArray)routerswitches.Clone(); } } solution.RoutersTurnedOff = ExtensionMethods.ConvertBitArrayToOffRouterNumbers(best, data.HostCount); }
public Node(BitArray parentAvailAttrs) { attrCount = Globals.attrCount; availableAttrs = (BitArray) parentAvailAttrs.Clone(); // !! tuples = new List<Tuple>(); childNodes = new List<Node>(); }
static public int Clone(IntPtr l) { try { System.Collections.BitArray self = (System.Collections.BitArray)checkSelf(l); var ret = self.Clone(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
//Runs the algoritm for number of iterations public override void Run(int iterations, int randseed) { log = new RandomLogSpecification(data.DataFileName, randseed, iterations); solution = new SolutionSpecification(); BitArray routerswitches = new BitArray((int)data.RouterCount); double highestfitness = 0.0; BitArray best = new BitArray((int)data.RouterCount); for(int i = 0; i < iterations; i++) { // Console.WriteLine("Run #" + i); routerswitches = new BitArray((int)data.RouterCount); // Console.WriteLine("Router count: " + routerswitches.Count); int numbertoswitch = randomgenerator.Next((int)data.RouterCount); // Console.WriteLine("Switching amount: " + numbertoswitch); for(int j = 0; j < numbertoswitch; j++) { int switching; while(routerswitches.Get(switching = randomgenerator.Next((int)data.RouterCount)) == true); // Console.WriteLine("Switching: " + switching); routerswitches.Set(switching, true); } double fitness = FitnessEvaluation(data.NetworkPaths, routerswitches, numbertoswitch); // Console.WriteLine("Fitness: " + fitness); if(fitness > highestfitness) { ((RandomLogSpecification)log).AddEvaluation(i, fitness); highestfitness = fitness; best = (BitArray)routerswitches.Clone(); } } solution.RoutersTurnedOff = ExtensionMethods.ConvertBitArrayToOffRouterNumbers(best, data.HostCount); }
public static void Subtract(BitArray a, BitArray b) { // a = a - b BitArray c = (BitArray) b.Clone(); a.And(c.Not()); }
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.SafeGet(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_UnequalLengths(a0); BitArray a_or = (BitArray)a.Clone(); a_or = a_or.Or_UnequalLengths(a0); BitArray a_xor = (BitArray)a.Clone(); a_xor = a_xor.Xor_UnequalLengths(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; } }
//Uses a bit mask to see if a path is cut by switching routers (on bits) in roterswitches off. private bool IsPathCut(BitArray path, BitArray routerswitches) { BitArray p = (BitArray)path.Clone(); BitArray r = (BitArray)routerswitches.Clone(); return (!ExtensionMethods.AreBitArraysEqual(path, p.And(r.Not()))); }
private void ComputeLocalLiveSets() { var liveSetTrace = new CompilerTrace(trace, "ComputeLocalLiveSets"); foreach (var block in extendedBlocks) { if (liveSetTrace.Active) liveSetTrace.Log("Block # " + block.BasicBlock.Sequence.ToString()); BitArray liveGen = new BitArray(registerCount, false); BitArray liveKill = new BitArray(registerCount, false); liveGen.Set(stackFrameRegister.Index, true); liveGen.Set(stackPointerRegister.Index, true); if (programCounter != null) liveGen.Set(programCounter.Index, true); for (Context context = new Context(instructionSet, block.BasicBlock); !context.IsBlockEndInstruction; context.GotoNext()) { if (context.IsEmpty) continue; if (liveSetTrace.Active) liveSetTrace.Log(context.ToString()); OperandVisitor visitor = new OperandVisitor(context); foreach (var ops in visitor.Input) { if (liveSetTrace.Active) liveSetTrace.Log("INPUT: " + ops.ToString()); int index = GetIndex(ops); if (!liveKill.Get(index)) { liveGen.Set(index, true); if (liveSetTrace.Active) liveSetTrace.Log("GEN: " + index.ToString() + " " + ops.ToString()); } } if (context.Instruction.FlowControl == FlowControl.Call) { for (int s = 0; s < physicalRegisterCount; s++) { liveKill.Set(s, true); } if (liveSetTrace.Active) liveSetTrace.Log("KILL ALL PHYSICAL"); } foreach (var ops in visitor.Output) { if (liveSetTrace.Active) liveSetTrace.Log("OUTPUT: " + ops.ToString()); int index = GetIndex(ops); liveKill.Set(index, true); if (liveSetTrace.Active) liveSetTrace.Log("KILL: " + index.ToString() + " " + ops.ToString()); } } block.LiveGen = liveGen; block.LiveKill = liveKill; block.LiveKillNot = ((BitArray)liveKill.Clone()).Not(); if (liveSetTrace.Active) { liveSetTrace.Log("GEN: " + ToString(block.LiveGen)); liveSetTrace.Log("KILL: " + ToString(block.LiveKill)); liveSetTrace.Log("KILLNOT: " + ToString(block.LiveKillNot)); liveSetTrace.Log(string.Empty); } } }
/// <summary> /// Метод перемішування. /// </summary> /// <param name="x"></param> /// <returns></returns> public double Method(double x) { var q = BitConverter.GetBytes(x); BitArray bits = new BitArray(q); var left = bits.Clone() as BitArray; var right = bits.Clone() as BitArray; //Кількість розрядів для здвигу. var offset = 2; //Здвиг for(int i = 0; i < offset; i++) { left = ShiftLeft(left); right = ShiftRight(right); } //Додавання лівої та правої частин. var newRandomNumberBitArray = Add(left, right); //Переведення масиву бітів в десяткове число. var newRandomNumber = BitConverter.ToDouble(BitArrayToByteArray(newRandomNumberBitArray), 0); var newnubmer1 = BitConverter.ToDouble(BitArrayToByteArray(left), 0); var newnumber2 = BitConverter.ToDouble(BitArrayToByteArray(right), 0); var sum = newnubmer1 + newnumber2; return Math.Abs(newRandomNumber); }
//Uses a bit mask to see if a path is cut by switching routers (on bits) in roterswitches off. protected bool IsPathCut(BitArray path, BitArray routerswitches) { BitArray p = (BitArray)path.Clone(); BitArray r = (BitArray)routerswitches.Clone(); //BitArray p = ExtensionMethods.CopyBitArrayValueWise(path); //BitArray r = ExtensionMethods.CopyBitArrayValueWise(routerswitches); return (!ExtensionMethods.AreBitArraysEqual(path, p.And(r.Not()))); }
/* * @returns false if we couldn't assign the integers */ private static bool AssignIntsToCriticalVertices(Graph graph, int[] g, BitArray ae, BitArray criticalNodes) { int x = 0; LinkedList<int> toProcess = new LinkedList<int>(); BitArray assigned = new BitArray(g.Length); while(!BitArrayEquals(assigned, criticalNodes)) { BitArray unprocessed = (BitArray)criticalNodes.Clone(); AndNot (unprocessed, assigned); toProcess.AddLast(NextSetBit(unprocessed, 0)); // start at the lowest unassigned critical vertex // assign another "tree" of vertices - not all critical ones are necessarily connected! x = ProcessCriticalNodes(toProcess, graph, ae, g, x, assigned, criticalNodes); if(x < 0) return false; // x is overloaded as a failure signal } return true; }
// Métodos agregados por Manuel para manejo de errores static BitArray addConjuntos(BitArray a, BitArray b) { BitArray c = (BitArray)a.Clone(); c.Or(b); return c; }
/* //Dibuja la grafica del wave entre los valores [-15,15] hace falta aplicarle un zoom del orden alto/10 //un buen valor seria asignar como zoom=zoomAux*alto/20 public Bitmap DrawWave(int[] bufferEntero, int ancho, int alto, double zoom, int modo) { int zancada = Convert.ToInt32(bufferEntero.Length) / ancho; Bitmap aux = new Bitmap(ancho, alto); if (modo < 0) modo = 0; if (modo > 3) modo = 3; // Tomamos las dimensiones de la imagen int width = aux.Width; int height = aux.Height; // Bloqueamos las imágenes BitmapData destinoDatos = aux.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); // Cogemos el ancho de línea de imagen int stride = destinoDatos.Stride; // El offset que hay que utilizar (para el relleno) int offset = stride - (width * 4); unsafe { // Empezamos en fila 0 columna 0 byte* dst = (byte*)destinoDatos.Scan0.ToPointer() + stride; try { for (int x = 0; x < width; x++, dst += 4) { double valorEnI = 0; for (int j = 0; j < zancada; j += zancada / 20) { valorEnI += bufferEntero[j + x * zancada]; } valorEnI = 20 * valorEnI / zancada; double rango; if (valorEnI > 0) { switch (modo) { case 3: rango = zoom * Math.Exp(Math.Log10(zoom * valorEnI / ((min_vol + max_vol) / 40))); break; case 2: rango = zoom * Math.Log(zoom * valorEnI / ((min_vol + max_vol) / 40), 2); break; case 1: rango = Math.Sqrt(zoom) * Math.Pow(1 + Math.Max(0, ((valorEnI - (min_vol + max_vol) / 50)) / (max_vol / 40)), zoom); break; default: rango = Math.Sqrt(zoom) * Math.Pow(1 + valorEnI / (max_vol / 20), zoom); break; } } else rango = 0; int arriba = Convert.ToInt32((aux.Height / 2) - rango); int abajo = Convert.ToInt32((aux.Height / 2) + rango); dst = (byte*)destinoDatos.Scan0.ToPointer() + stride; dst += x * 4 + stride * arriba; for (int y = arriba; y <= abajo; y++, dst += stride) { dst[0] = 255; dst[1] = 0; dst[2] = 0; dst[3] = 255; }//fin for }//fin for } catch { //algun puntero se acaba escapando } } aux.UnlockBits(destinoDatos); return aux; } */ private int Convierte(int a) { int numBits = 16; BitArray b = new BitArray(new int[] { a }); BitArray bAux = (BitArray)b.Clone(); for (int i = 0; i < b.Length; i++) { b[i] = bAux[b.Length - 1 - i]; } int result = -(a & (1 << numBits - 1)); for (int i = numBits - 2; i >= 0; i--) result |= (a & (1 << i)); return result; }
protected int Transitions(BitArray to = null, BitArray from = null) { if (to == null) to = BlankSegments; if (from == null) from = BlankSegments; var cloneTo = (BitArray) to.Clone(); var cloneFrom = (BitArray)from.Clone(); var diff = cloneTo.Xor(cloneFrom); return diff.Cast<bool>().Count(b => b); }
public virtual Dictionary<string, int> RunFacet(Query query, bool showAllVersions, bool isFacet, bool isIdLookup, int pageSize, int pageNumber, string termName, List<string> termValue, BitArray queryBase, string locationFilter) { var runningCOunt = new Dictionary<string, int>(); var db = Context.ContentDatabase ?? Sitecore.Context.Database; var indexName = BucketManager.GetContextIndex(db.GetItem(locationFilter)); if (indexName.EndsWith("_remote")) { Index = RemoteSearchManager.GetIndex(indexName) as RemoteIndex; } else if (indexName.EndsWith("_inmemory")) { Index = InMemorySearchManager.GetIndex(indexName) as InMemoryIndex; } else { Index = SearchManager.GetIndex(indexName) as Index; } using (var context = new SortableIndexSearchContext(Index)) { if (Config.EnableBucketDebug || Constants.EnableTemporaryBucketDebug) { Log.Info("Using: " + indexName, this); Log.Info("Bucket Facet Original Debug Query: " + query, this); } foreach (var terms in termValue) { var genreQueryFilter = GenreQueryFilter(query, isFacet, isIdLookup, termName, terms); var tempSearchArray = queryBase.Clone() as BitArray; if (Config.EnableBucketDebug || Constants.EnableTemporaryBucketDebug) { Log.Info("Bucket Facet Debug Query: " + genreQueryFilter, this); } BitArray genreBitArray = genreQueryFilter.Bits(context.Searcher.GetIndexReader()); if (tempSearchArray.Length == genreBitArray.Length) { BitArray combinedResults = tempSearchArray.And(genreBitArray); var cardinality = SearchHelper.GetCardinality(combinedResults); if (cardinality > 0) { if (!isFacet) { if (!runningCOunt.ContainsKey(terms)) { runningCOunt.Add(terms, cardinality); } } else { if (!runningCOunt.ContainsKey(terms)) { runningCOunt.Add(terms, cardinality); } } } } } } return runningCOunt; }
private static void AssignIntsToNonCriticalVertices(Graph graph, int[] g, BitArray ae, BitArray criticalNodes) { LinkedList<int> toProcess = new LinkedList<int>(); for(int v = NextSetBit(criticalNodes, 0); v != -1; v = NextSetBit(criticalNodes, v+1)) { toProcess.AddLast(v); } // load with the critical vertices BitArray visited = (BitArray) criticalNodes.Clone(); ProcessNonCriticalNodes(toProcess, graph, ae, visited, g); // process the critical nodes // we've done everything reachable from the critical nodes - but // what about isolated chains? for(int v = NextClearBit(visited, 0); v != -1 && v < g.Length; v = NextClearBit(visited, v+1)) { toProcess.AddLast(v); ProcessNonCriticalNodes(toProcess, graph, ae, visited, g); } }
int NewCondSet(BitArray s) { for (int i = 1; i < symSet.Count; i++) // skip symSet[0] (reserved for union of SYNC sets) if (Sets.Equals(s, (BitArray)symSet[i])) return i; symSet.Add(s.Clone()); return symSet.Count - 1; }
/// <summary> Zjistí, jestli 2 bitová pole mají spoleèné bity. </summary> /// <param name="bits1"> 1. bitové pole. </param> /// <param name="bits2"> 2. bitové pole. </param> /// <param name="samesize"> true pokud musí být obì pole stejné délky. </param> /// <returns> true, pokud mají obì pole spoleèné bity. </returns> public static bool BitsIntersect ( BitArray bits1, BitArray bits2, bool samesize ) { if ( bits1 != null && bits2 != null ) { BitArray intersection; if ( bits1.Length == bits2.Length ) intersection = ((BitArray)bits1.Clone()).And( bits2 ); else { if ( samesize ) throw new Exception( string.Format( "Other.BitsIntersect: BitArrays nemají stejnou velikost {0} <> {1}", bits1.Length, bits2.Length ) ); BitArray bits1Temp, bits2Temp; if ( bits1.Length > bits2.Length ) { bits1Temp = ShortenBitArray( bits1, bits2.Length ); bits2Temp = bits2; } else { bits1Temp = (BitArray)bits1.Clone(); bits2Temp = ShortenBitArray( bits2, bits1.Length ); } intersection = bits1Temp.And( bits2Temp ); } for ( int i = intersection.Length ; --i >= 0 ; ) if ( intersection[i] ) return true; } return false; }