public LinqHashSet(IEnumerable <T> e) : this() { foreach (var x in e) { Inner.Add(x, ""); } }
protected void SelectClicked( Func <List <MediaCardViewModel> > getSortedItems, MediaCardViewModel card, MouseEventArgs e) { if (_selectedItems.Contains(card)) { _selectedItems.Remove(card); } else { if (e.ShiftKey && _recentlySelected.IsSome) { List <MediaCardViewModel> sorted = getSortedItems(); int start = sorted.IndexOf(_recentlySelected.ValueUnsafe()); int finish = sorted.IndexOf(card); if (start > finish) { int temp = start; start = finish; finish = temp; } for (int i = start; i < finish; i++) { _selectedItems.Add(sorted[i]); } } _recentlySelected = card; _selectedItems.Add(card); } }
private void Start() { if (HeadCamera != null && TopCamera != null) { HeadCamera.enabled = true; TopCamera.enabled = false; } knownActions.Add("Strafe"); knownActions.Add("Vertical"); knownActions.Add("Horizontal"); knownActions.Add("Action"); knownActions.Add(""); RotateTo(m_CurrentDirection, false); MapGenerator.getInstance().Initialize(); new Thread(o => { var player = new Player(); player.Start(); while (true) { player.Tick(); Thread.Sleep(1); } }).Start(); }
public void ISet_Generic_SymmetricExceptWith_AfterRemovingElements(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements) { ISet <T> set = GenericISetFactory(setLength); T value = CreateT(532); if (!set.Contains(value)) { set.Add(value); } set.Remove(value); IEnumerable <T> enumerable = CreateEnumerable(enumerableType, set, enumerableLength, numberOfMatchingElements, numberOfDuplicateElements); Debug.Assert(enumerable != null); IEqualityComparer <T> comparer = GetIEqualityComparer(); System.Collections.Generic.HashSet <T> expected = new System.Collections.Generic.HashSet <T>(comparer); foreach (T element in enumerable) { if (!set.Contains(element, comparer)) { expected.Add(element); } } foreach (T element in set) { if (!enumerable.Contains(element, comparer)) { expected.Add(element); } } set.SymmetricExceptWith(enumerable); Assert.Equal(expected.Count, set.Count); Assert.True(expected.SetEquals(set)); }
public void TryAddLibrary(string AssetPath) { Active = true; if (AssetPath.Contains(".a")) { //Extract the lib name, generate the registration code. var begin = AssetPath.LastIndexOf('/') + 4; var end = AssetPath.LastIndexOf('.') - begin; var LibName = AssetPath.Substring(begin, end); //Remove the lib prefix and the .a extension if (!LibName.Contains("AkSoundEngine")) { string headerFilename = LibName + "Factory.h"; string fullPath = System.IO.Path.Combine(UnityEngine.Application.dataPath, WwisePluginFolder + GetWwisePluginRelativeDSPFolder() + headerFilename); if (System.IO.File.Exists(fullPath)) { FactoriesHeaderFilenames.Add(headerFilename); } else { UnityEngine.Debug.LogErrorFormat("WwiseUnity: Could not find '{0}', required for building plugin.", WwisePluginFolder + GetWwisePluginRelativeDSPFolder() + headerFilename); } } } else if (AssetPath.Contains("Factory.h")) { FactoriesHeaderFilenames.Add(System.IO.Path.GetFileName(AssetPath)); } }
public void add_bad_mapping(string p_key) { if (!FoundPaths.Contains(p_key)) { FoundPaths.Add(p_key); BadMappingLog.WriteLine(p_key); } }
public HashSet<string> HashSet() { HashSet<string> set = new System.Collections.Generic.HashSet<string>(); set.Add("wenbin1"); set.Add("wenbin2"); set.Add("wenbin3"); set.Add("wenbin4"); return set; }
private void Cleaning(SplitTree ST, SplitTree tPrime) { //different from original algorithm 7, since the structure of T' is marked with visited flags, here we don't reset the flags //scan T' twice System.Collections.Generic.HashSet<MarkerVertex> A = new System.Collections.Generic.HashSet<MarkerVertex>(); System.Collections.Generic.HashSet<MarkerVertex> B = new System.Collections.Generic.HashSet<MarkerVertex>(); for (int i = 0, n = tPrime.vertices.Count; i < n; ++i) { if (tPrime.vertices[i] is DegenerateNode) { var deg = tPrime.vertices[i] as DegenerateNode; A.Clear();//Here A is P* and B is V \ P* B.Clear(); deg.ForEachMarkerVertex((v) => { if (v.perfect && v != deg.center) A.Add(v); else B.Add(v); return IterationFlag.Continue; }); if (A.Count > 1 && B.Count > 1) { var newNode = SplitNode(deg, B, A); if (newNode.parent == deg) newNode.rootMarkerVertex.opposite.MarkAsPerfect(); else deg.rootMarkerVertex.MarkAsPerfect(); ST.vertices.Add(newNode);//In this way, the structure of T' is unchanged as the newly forked node contains P*(u) } } } //again we don't need to reset flags for (int i = 0, n = tPrime.vertices.Count; i < n; ++i) { if (tPrime.vertices[i] is DegenerateNode) { var deg = tPrime.vertices[i] as DegenerateNode; A.Clear();//Here A is V \ E* and B is E B.Clear(); deg.ForEachMarkerVertex((v) => { if ((v.perfect && v == deg.center) || (!v.perfect && !deg.GetOppositeGLTVertex(v).visited))//if v is not P and is not incident to a tree edge in T', it is E* B.Add(v); else A.Add(v); return IterationFlag.Continue; }); if (A.Count > 1 & B.Count > 1) { ST.vertices.Add(SplitNode(deg, A, B));//let V \ E* be preserved in T' } } } //and we're done with cl(ST(G)) and T_c. }
//! Start. protected void Start() { // Reset for start node g_score[start] = 0; // Recalculate estimate distance. f_score[start] = g_score[start] + Heurestic(start, end_); initialEstimate = f_score[start]; // Push starting node openSet.Add(start); openSetPriority.Push(new NodeTag(f_score[start], start)); }
public static void Write(TextWriter writer, IEnumerable <Dictionary <string, string> > records) { if (records == null) { return; //AOT } var allKeys = new System.Collections.Generic.HashSet <string>(); var cachedRecords = new List <IDictionary <string, string> >(); foreach (var record in records) { foreach (var key in record.Keys) { if (!allKeys.Contains(key)) { allKeys.Add(key); } } cachedRecords.Add(record); } var headers = allKeys.OrderBy(key => key).ToList(); if (!CsvConfig <Dictionary <string, string> > .OmitHeaders) { WriteRow(writer, headers); } foreach (var cachedRecord in cachedRecords) { var fullRecord = headers.ConvertAll(header => cachedRecord.ContainsKey(header) ? cachedRecord[header] : null); WriteRow(writer, fullRecord); } }
public List <S> Find_path(S start, S end) { System.Collections.Generic.HashSet <S> closedSet = new System.Collections.Generic.HashSet <S>(); IntervalHeap <Node> openSet = new IntervalHeap <Node>(); Node curr = new Node(start, null); while (!curr.state.Equals(end)) { if (!closedSet.Contains(curr.state)) { foreach (S state in curr.state.AvailableMoves()) { if (closedSet.Contains(state)) { continue; } openSet.Add(new Node(state, curr)); } closedSet.Add(curr.state); } curr = openSet.DeleteMin(); } Stack <S> stack = new Stack <S>(); while (curr != null) { stack.Push(curr.state); curr = curr.parent; } return(stack.ToList <S>()); }
protected override void SaveChanges(Context context, RecordModel record = null) { base.SaveChanges(context, record); if (record == null) { return; } var users = new System.Collections.Generic.HashSet <AspNetUsers>(); foreach (var group in record.ApplicationGroups) { foreach (var user in group.AspNetUsers) { users.Add(user); } } foreach (var user in users) { if (AspNetUsersHub.SyncUserRoles(user)) { AddChange("AspNetUsers", "change", user.Id); base.SaveChanges(context, record); } } }
public Stack <Point> Run() { while (!Open.IsEmpty) { var node = Open.DeleteMin(); // node.State.print(); if (Game.IsFinishState(node.State)) { var stack = new Stack <Point>(); while (node.Parent != null) { stack.Push(node.Move); node = node.Parent; } return(stack); } foreach (var move in ProductionSystem) { var newNode = new Node(node, Game.MakeMove(node.State, move), move); if (!Closed.Contains(newNode)) { Open.Add(newNode); } } Closed.Add(node); } System.Console.WriteLine("No solution found."); return(null); }
public static System.Collections.Generic.HashSet <string> FindDuplicatePrefabs(IEnumerable <GameObject> prefabs) { var duplicates = new System.Collections.Generic.HashSet <string>(); var previous = new System.Collections.Generic.Dictionary <string, GameObject>(); foreach (GameObject go in prefabs) { if (go == null || PrefabUtility.GetPrefabType(go) != PrefabType.Prefab) { continue; } string name = go.name; GameObject previousGo; if (previous.TryGetValue(name, out previousGo)) { if (previousGo != go) { duplicates.Add(name); } } else { previous.Add(name, go); } } return(duplicates); }
public static void Write(TextWriter writer, IEnumerable<Dictionary<string, string>> records) { if (records == null) return; //AOT var allKeys = new System.Collections.Generic.HashSet<string>(); var cachedRecords = new List<IDictionary<string, string>>(); foreach (var record in records) { foreach (var key in record.Keys) { if (!allKeys.Contains(key)) { allKeys.Add(key); } } cachedRecords.Add(record); } var headers = allKeys.OrderBy(key => key).ToList(); if (!CsvConfig<Dictionary<string, string>>.OmitHeaders) { WriteRow(writer, headers); } foreach (var cachedRecord in cachedRecords) { var fullRecord = new List<string>(); foreach (var header in headers) { fullRecord.Add(cachedRecord.ContainsKey(header) ? cachedRecord[header] : null); } WriteRow(writer, fullRecord); } }
public void RTree_Deletion_Test() { var nodeCount = 1000; var randomPolygons = new System.Collections.Generic.HashSet <Polygon>(); for (int i = 0; i < nodeCount; i++) { randomPolygons.Add(getRandomPointOrPolygon()); } var order = 5; var tree = new RTree(order); foreach (var polygon in randomPolygons) { tree.Insert(polygon); } int j = randomPolygons.Count; foreach (var polygon in randomPolygons) { tree.Delete(polygon); Assert.IsFalse(tree.Exists(polygon)); j--; if (j > 0) { var actualMaxHeight = tree.Root.Height; Assert.AreEqual(verifyHeightUniformityAndReturnHeight(tree.Root, order), actualMaxHeight); Assert.AreEqual(j, tree.Count); } } }
public static void LoadXmlDocumentation(Assembly assembly) { string xmlFilePath; if (LoadedAssemblies.Contains(assembly)) { return; } var directoryPath = assembly.GetDirectoryPath(); if (!string.IsNullOrEmpty(directoryPath)) { xmlFilePath = Path.Combine(directoryPath, assembly.GetName().Name + ".xml"); } else { xmlFilePath = assembly.GetName().Name + ".xml"; } if (File.Exists(xmlFilePath)) { using var streamReader = new StreamReader(xmlFilePath); LoadXmlDocumentation(streamReader); } // currently marking assembly as loaded even if the XML file was not found // may want to adjust in future, but I think this is good for now LoadedAssemblies.Add(assembly); }
/// <summary> /// Do DFS to find all unique edges. /// </summary> private void dfs(WeightedGraphVertex <T, TW> currentVertex, System.Collections.Generic.HashSet <T> visitedVertices, Dictionary <T, System.Collections.Generic.HashSet <T> > visitedEdges, List <MSTEdge <T, TW> > result) { if (!visitedVertices.Contains(currentVertex.Value)) { visitedVertices.Add(currentVertex.Value); foreach (var edge in currentVertex.Edges) { if (!visitedEdges.ContainsKey(currentVertex.Value) || !visitedEdges[currentVertex.Value].Contains(edge.Key.Value)) { result.Add(new MSTEdge <T, TW>(currentVertex.Value, edge.Key.Value, edge.Value)); //update visited edge if (!visitedEdges.ContainsKey(currentVertex.Value)) { visitedEdges.Add(currentVertex.Value, new HashSet <T>()); } visitedEdges[currentVertex.Value].Add(edge.Key.Value); //update visited back edge if (!visitedEdges.ContainsKey(edge.Key.Value)) { visitedEdges.Add(edge.Key.Value, new HashSet <T>()); } visitedEdges[edge.Key.Value].Add(currentVertex.Value); } dfs(edge.Key, visitedVertices, visitedEdges, result); } } }
public ListNode DetectCycle(ListNode head) { /* Dictionary<ListNode, int> tmp = new Dictionary<ListNode, int> (); * int pos = -1; * while (head != null) { * pos++; * if (tmp.ContainsKey (head)) { * return head; * } * tmp.Add (head, pos); * head = head.next; * } * return null; */ HashSet <ListNode> nodeset = new System.Collections.Generic.HashSet <ListNode> (); while (head != null) { if (nodeset.Contains(head)) { return(head); } nodeset.Add(head); head = head.next; } return(null); }
/// <summary> /// Validates this node and all its descendents. /// </summary> public static void ValidateInternalIntegrity(TRecursiveParent parent) { // Each node id appears at most once. if (parent.Children?.Count > 0) { var observedIdentities = new System.Collections.Generic.HashSet <IdentityFieldType>(); foreach (var node in parent.GetSelfAndDescendents()) { if (!observedIdentities.Add(node.Identity)) { throw new RecursiveChildNotUniqueException(node.Identity); } } } // The lookup table (if any) accurately describes the contents of this tree. if (parent.LookupTable != null && parent.LookupTable != LazySentinel) { // The table should have one entry for every *descendent* of this node (not this node itself). int expectedCount = parent.GetSelfAndDescendents().Count() - 1; int actualCount = parent.LookupTable.Count; Assumes.False(actualCount != expectedCount, "Expected {0} entries in lookup table but found {1}.", expectedCount, actualCount); ValidateLookupTable(parent, parent.LookupTable); } }
private IEnumerable <NewEvent> ProcessEvent(Event evnt) { var eventValue = evnt.Value; List <NewEvent> newEvents = new List <NewEvent>(); switch (eventValue.Type) { case EventType.NewStory: newEvents.Add(new NewEvent(Distribution.NextStory, new EventValue(EventType.NewStory))); var storyId = _storyIdCounter++; _storiesInProgress.Add(storyId); newEvents.Add(new NewEvent(Distribution.StoryCycleTime, new EventValue(EventType.StoryFinish, storyId))); break; case EventType.StoryFinish: var cycleTime = evnt.Time - evnt.StartTime; _simulatedStoryCycleTimes.Add(cycleTime); _storiesInProgress.Remove(eventValue.StoryId); break; case EventType.Sample: newEvents.Add(new NewEvent(Distribution.Unit, new EventValue(EventType.Sample))); _storiesInProgressSample.Add(_storiesInProgress.Count); break; default: throw new ArgumentOutOfRangeException(); } return(newEvents); }
public void RTree_Insertion_Test() { var nodeCount = 1000; var randomPolygons = new System.Collections.Generic.HashSet <Polygon>(); for (int i = 0; i < nodeCount; i++) { randomPolygons.Add(getRandomPointOrPolygon()); } var order = 5; var tree = new RTree(order); int j = 0; foreach (var polygon in randomPolygons) { tree.Insert(polygon); //height should be similar to that of B+ tree. //https://en.wikipedia.org/wiki/B-tree#Best_case_and_worst_case_heights var theoreticalMaxHeight = Math.Ceiling(Math.Log((j + 2) / 2, (int)Math.Ceiling((double)order / 2))) + 1; var actualMaxHeight = tree.Root.Height; Assert.AreEqual(verifyHeightUniformityAndReturnHeight(tree.Root, order), actualMaxHeight); Assert.IsTrue(actualMaxHeight <= theoreticalMaxHeight); j++; Assert.IsTrue(tree.Exists(polygon)); } Assert.AreEqual(j, tree.Count); }
//Typical data in navigator: <test weight="5" type="exact" flag="SA" tcpsig="65535:128:1:48:M1460,N,N,S:."/> internal Test(XPathNavigator testXPathNavigator, string osClass, string osDetails) { testXPathNavigator.MoveToFirstAttribute(); //attributeList=new System.Collections.Specialized.NameValueCollection(); this.tcpflags = new HashSet <char>(); this.p0fFingerprint = null; do { //attributeList.Add(testXPathNavigator.Name, testXPathNavigator.Value); if (testXPathNavigator.Name == "weight") { this.weight = Convert.ToInt32(testXPathNavigator.Value); } if (testXPathNavigator.Name == "tcpsig") { this.p0fFingerprint = new P0fOsFingerprintCollection.P0fFingerprint(testXPathNavigator.Value + ":" + osClass + ":" + osDetails); } if (testXPathNavigator.Name == "tcpflag") { foreach (char c in testXPathNavigator.Value.ToCharArray()) { tcpflags.Add(c); } } }while(testXPathNavigator.MoveToNextAttribute()); }
internal override void GetResAsset(System.Collections.Generic.HashSet <string> setRes) { if (mEffectName != string.Empty) { setRes.Add(mEffectName); } }
private void Validate_IntersectWith(ISet <T> set, IEnumerable <T> enumerable) { if (set.Count == 0 || Enumerable.Count(enumerable) == 0) { set.IntersectWith(enumerable); Assert.Equal(0, set.Count); } else if (set == enumerable) { System.Collections.Generic.HashSet <T> beforeOperation = new System.Collections.Generic.HashSet <T>(set, GetIEqualityComparer()); set.IntersectWith(enumerable); Assert.True(beforeOperation.SetEquals(set)); } else { IEqualityComparer <T> comparer = GetIEqualityComparer(); System.Collections.Generic.HashSet <T> expected = new System.Collections.Generic.HashSet <T>(comparer); foreach (T value in set) { if (enumerable.Contains(value, comparer)) { expected.Add(value); } } set.IntersectWith(enumerable); Assert.Equal(expected.Count, set.Count); Assert.True(expected.SetEquals(set)); } }
/// <summary> /// Do DFS to pick smallest weight neighbour edges /// of current spanning tree one by one /// </summary> /// <param name="graph"></param> /// <param name="currentVertex"></param> /// <param name="spanTreeVertices"></param> /// <param name="spanTreeNeighbours"> Use Fibornacci Min Heap to pick smallest edge neighbour </param> /// <param name="spanTreeEdges">result MST edges</param> private void dfs(WeightedGraph <T, W> graph, WeightedGraphVertex <T, W> currentVertex, BMinHeap <MSTEdge <T, W> > spanTreeNeighbours, System.Collections.Generic.HashSet <T> spanTreeVertices, List <MSTEdge <T, W> > spanTreeEdges) { while (true) { //add all edges to Fibornacci Heap //So that we can pick the min edge in next step foreach (var edge in currentVertex.Edges) { spanTreeNeighbours.Insert(new MSTEdge <T, W>(currentVertex.Value, edge.Key.Value, edge.Value)); } //pick min edge var minNeighbourEdge = spanTreeNeighbours.ExtractMin(); //skip edges already in MST while (spanTreeVertices.Contains(minNeighbourEdge.Source) && spanTreeVertices.Contains(minNeighbourEdge.Destination)) { minNeighbourEdge = spanTreeNeighbours.ExtractMin(); //if no more neighbours to explore //time to end exploring if (spanTreeNeighbours.Count == 0) { return; } } //keep track of visited vertices //do not duplicate vertex if (!spanTreeVertices.Contains(minNeighbourEdge.Source)) { spanTreeVertices.Add(minNeighbourEdge.Source); } //Destination vertex will never be a duplicate //since this is an unexplored Vertex spanTreeVertices.Add(minNeighbourEdge.Destination); //add edge to result spanTreeEdges.Add(minNeighbourEdge); //now explore the destination vertex var graph1 = graph; currentVertex = graph1.Vertices[minNeighbourEdge.Destination]; } }
public static void CollectMapping(Activity rootActivity1, Activity rootActivity2, Dictionary<object, SourceLocation> mapping, string path) { Activity activity = (rootActivity1.RootActivity != null) ? rootActivity1.RootActivity : rootActivity1; if (!activity.IsRuntimeReady) { IList<ValidationError> validationErrors = null; ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors); } Activity activity2 = (rootActivity2.RootActivity != null) ? rootActivity2.RootActivity : rootActivity2; if (!activity2.IsRuntimeReady) { IList<ValidationError> list2 = null; ActivityUtilities.CacheRootMetadata(activity2, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref list2); } Queue<KeyValuePair<Activity, Activity>> queue = new Queue<KeyValuePair<Activity, Activity>>(); queue.Enqueue(new KeyValuePair<Activity, Activity>(rootActivity1, rootActivity2)); System.Collections.Generic.HashSet<Activity> set = new System.Collections.Generic.HashSet<Activity>(); while (queue.Count > 0) { SourceLocation location; KeyValuePair<Activity, Activity> pair = queue.Dequeue(); Activity key = pair.Key; Activity activity4 = pair.Value; set.Add(key); if (TryGetSourceLocation(activity4, path, out location)) { mapping.Add(key, location); } else if (!(activity4 is IExpressionContainer) && !(activity4 is IValueSerializableExpression)) { Debugger.Log(2, "Workflow", "WorkflowDebugger: Does not have corresponding Xaml node for: " + activity4.DisplayName + "\n"); } if ((!(key is IExpressionContainer) && !(activity4 is IExpressionContainer)) && (!(key is IValueSerializableExpression) && !(activity4 is IValueSerializableExpression))) { IEnumerator<Activity> enumerator = WorkflowInspectionServices.GetActivities(key).GetEnumerator(); IEnumerator<Activity> enumerator2 = WorkflowInspectionServices.GetActivities(activity4).GetEnumerator(); bool flag = enumerator.MoveNext(); bool flag2 = enumerator2.MoveNext(); while (flag && flag2) { if (!set.Contains(enumerator.Current)) { if (enumerator.Current.GetType() != enumerator2.Current.GetType()) { Debugger.Log(2, "Workflow", "Unmatched type: " + enumerator.Current.GetType().FullName + " vs " + enumerator2.Current.GetType().FullName + "\n"); } queue.Enqueue(new KeyValuePair<Activity, Activity>(enumerator.Current, enumerator2.Current)); } flag = enumerator.MoveNext(); flag2 = enumerator2.MoveNext(); } if (flag || flag2) { Debugger.Log(2, "Workflow", "Unmatched number of children\n"); } } } }
private void _Decompose(ParameterSyntax node) { var kind = node.Type.Kind(); _Types.Add(node.Type.ToFullString()); if (kind != SyntaxKind.PredefinedType) { } }
public override bool AddItem(T element) { if (table.Add(element)) { list.Add(element); return(true); } return(false); }
static VisualBasicSettings() { System.Collections.Generic.HashSet <VisualBasicImportReference> set = new System.Collections.Generic.HashSet <VisualBasicImportReference>(); VisualBasicImportReference item = new VisualBasicImportReference { Import = "System", Assembly = "mscorlib" }; set.Add(item); VisualBasicImportReference reference2 = new VisualBasicImportReference { Import = "System.Collections", Assembly = "mscorlib" }; set.Add(reference2); VisualBasicImportReference reference3 = new VisualBasicImportReference { Import = "System.Collections.Generic", Assembly = "mscorlib" }; set.Add(reference3); VisualBasicImportReference reference4 = new VisualBasicImportReference { Import = "System", Assembly = "system" }; set.Add(reference4); VisualBasicImportReference reference5 = new VisualBasicImportReference { Import = "System.Collections.Generic", Assembly = "system" }; set.Add(reference5); VisualBasicImportReference reference6 = new VisualBasicImportReference { Import = "System.Activities", Assembly = "System.Activities" }; set.Add(reference6); VisualBasicImportReference reference7 = new VisualBasicImportReference { Import = "System.Activities.Statements", Assembly = "System.Activities" }; set.Add(reference7); VisualBasicImportReference reference8 = new VisualBasicImportReference { Import = "System.Activities.Expressions", Assembly = "System.Activities" }; set.Add(reference8); defaultImportReferences = set; defaultSettings = new VisualBasicSettings(defaultImportReferences); }
private HashSet <int> getAllItems() { var result = new System.Collections.Generic.HashSet <int>(); foreach (var id in Enum.GetValues(typeof(ItemIds))) { result.Add((int)id); } return(result); }
/// <summary> /// BFS + A-star /// </summary> /// <returns>First item - first step to end, do not equal start. End included as last item.</returns> public TNode[] GetPath(TNode start, TNode end) { var visited = new System.Collections.Generic.HashSet <TNode>(new[] { start }); var queue = new IntervalHeap <TNode>(CreateComparer(end)) { start }; var parents = new Dictionary <TNode, TNode>(); while (queue.Count > 0) { var current = queue.DeleteMin(); foreach (var neighbour in GetNeighbours(current)) { if (visited.Contains(neighbour)) { continue; } parents[neighbour] = current; if (neighbour.Equals(end)) { var result = new List <TNode>(new[] { end }); while (!current.Equals(start)) { result.Add(current); current = parents[current]; } result.Reverse(); return(result.ToArray()); } queue.Add(neighbour); visited.Add(neighbour); } visited.Add(current); } return(Array.Empty <TNode>()); }
public ListNode deleteDuplication(ListNode pHead) { if (pHead == null) { return(pHead); } var values = new System.Collections.Generic.HashSet <int>(); var dupValues = new System.Collections.Generic.HashSet <int>(); var node = pHead; values.Add(node.val); while (node.next != null) { if (values.Contains(node.next.val)) { dupValues.Add(node.next.val); } values.Add(node.next.val); node = node.next; } var temp = new ListNode(1); temp.next = pHead; node = temp; while (node.next != null) { if (dupValues.Contains(node.next.val)) { node.next = node.next.next; } else { node = node.next; } } return(temp.next); }
static void Main(string[] args) { HashSet <int> x = new System.Collections.Generic.HashSet <int>(); x.Add(1); x.Add(2); x.Add(1); HashSet <Person> p = new HashSet <Person>(); p.Add(new Person("pawel")); p.Add(new Person("pawel")); p.Add(new Person("marcin")); p.Add(new Person("gosia")); p.Add(new Person("magda")); Console.WriteLine("Hello World!"); Console.ReadLine(); }
public IEnumerable<IDataObject> BindRdfDataObjects(IGraph graph) { var distinctSubjects = new System.Collections.Generic.HashSet<INode>(); foreach (var t in graph.Triples) { distinctSubjects.Add(t.Subject); } return distinctSubjects.Select(s => MakeDataObject(s.ToString(), graph.GetTriplesWithSubject(s).Select(t => MakeTriple(t.Subject, t.Predicate, t.Object)))); }
private static void setupAsterismGrabbers() { GameObject starRoot = new GameObject("StarRoot"); for(int i=0; i < AsterismData.Length; i++) { Asterism asterism = AsterismData[i]; Vector3 centroid = averageStarLocations(asterism.HD_ids); GameObject newRoot = new GameObject(); GameObject rest = new GameObject(); GameObject jewelcase = new GameObject(); newRoot.name = asterism.name + "_root"; newRoot.transform.position = centroid; newRoot.transform.rotation = Quaternion.identity; rest.name = "rest"; rest.transform.parent = newRoot.transform; rest.transform.localPosition = Vector3.zero; rest.transform.localRotation = Quaternion.identity; rest.transform.localScale = new Vector3(1.0f,1.0f,1.0f); jewelcase.name = "jewelcase"; jewelcase.transform.parent = newRoot.transform; jewelcase.transform.localPosition = Vector3.zero; jewelcase.transform.localRotation = Quaternion.identity; jewelcase.transform.localScale = new Vector3(1.0f,1.0f,1.0f); PullToHold pullscript = jewelcase.AddComponent<PullToHold>(); pullscript.asterismKey = i; pullscript.rest = rest.transform; pullscript.maxSpeed = 20.0f; newRoot.transform.parent = starRoot.transform; asterism.root = newRoot; asterism.rest = rest; asterism.mover = jewelcase; System.Collections.Generic.HashSet<uint> used = new System.Collections.Generic.HashSet<uint>(); GameObject constellationLabel = GameObject.Instantiate(Stars.StarUpdater.Instance.ConstellationLabelPrototype) as GameObject; constellationLabel.SetActive(true); ConstellationLabel labelBehavior = constellationLabel.GetComponent<ConstellationLabel>(); if ( asterism.root != null ) { labelBehavior.transform.parent = asterism.root.transform; } labelBehavior.Label = asterism.name; labelBehavior.transform.localPosition = (asterism.root.transform.position.normalized * 500.0f); asterism.label = labelBehavior; labelBehavior.LabelComp.color = new Color(1.0f, 1.0f, 1.0f, Stars.StarUpdater.Instance.LabelOpacity * 0.8f); Stars.StarUpdater.Instance.m_constellationLabels.Add(labelBehavior); foreach(uint hdId in asterism.HD_ids) { if ( !Stars.StarParser.HD_idToIndex.ContainsKey(hdId) ) { continue; } int index = Stars.StarParser.HD_idToIndex[hdId]; Stars.StarData star = Stars.StarParser.Instance.Stars[index]; star.AsterismIndex = i; Stars.StarParser.Instance.Stars[index] = star; if ( star.GameObjectRepresentation != null ) { star.GameObjectRepresentation.name = hdId.ToString(); star.GameObjectRepresentation.transform.parent = jewelcase.transform; if (star.Label != ""){ if(used.Contains(star.HD_id)) { continue; } Stars.StarUpdater.Instance.GenerateStarLabel(star, star.GameObjectRepresentation.transform); used.Add(star.HD_id); } } } AsterismData[i] = asterism; } }
private void DecorateCodeNamespace(CodeNamespace codeNamespace) { // Generate the schema set code namespace CodeNamespace schemaSetCodeNamespace = GenerateSchemaTypes(); // Add the code namespace to a fast search structure // KeyValuePair<type , namespace> HashSet<KeyValuePair<string, string>> typeSet = new System.Collections.Generic.HashSet<KeyValuePair<string, string>>(); foreach (CodeTypeDeclaration ctd in codeNamespace.Types) { XmlQualifiedName typeQn = GetCodeTypeXmlQName(ctd); typeSet.Add(new KeyValuePair<string, string>(typeQn.Name, typeQn.Namespace)); } // add the missing types from the schema code namespace to the main code namespace foreach (CodeTypeDeclaration sctd in schemaSetCodeNamespace.Types) { XmlQualifiedName typeQn = GetCodeTypeXmlQName(sctd); if (!typeSet.Contains(new KeyValuePair<string, String>(typeQn.Name, typeQn.Namespace))) { codeNamespace.Types.Add(sctd); } } }
//uPrime is the child of u //the result of the join is returned. private PrimeNode NodeJoin(SplitTree ST, Node u, Node uPrime) { MarkerVertex qPrime = uPrime.rootMarkerVertex; MarkerVertex q = qPrime.opposite as MarkerVertex; PrimeNode ret = null; List<GLTVertex> uPrimeChildren = new List<GLTVertex>(); if (u is DegenerateNode) { ret = (u as DegenerateNode).ConvertToPrime(); //u.parentLink = ret; //u.unionFind_parent = null; u.active = true; } else ret = u as PrimeNode; var representative = ret.childSetRepresentative; if (uPrime is DegenerateNode && (uPrime as DegenerateNode).isStar && qPrime != (uPrime as DegenerateNode).center)//qPrime has degree 1, not center. { var center = (uPrime as DegenerateNode).center; var centerOpposite = center.GetOppositeGLTVertex(); //Algorithm 8 says q now represents the center of u', so we have to update the center's opposite.. if (centerOpposite is Node) { (centerOpposite as Node).rootMarkerVertex.opposite = q; } else (centerOpposite as Leaf).opposite = q; uPrimeChildren.Add(centerOpposite); //And also copy the center's perfect state, and opposite. q.perfect = center.perfect; q.opposite = center.opposite; (uPrime as DegenerateNode).ForEachMarkerVertex((v) => { if (v != center && v != qPrime) { ret.AddMarkerVertex(v, new HashSet<MarkerVertex> { q }); uPrimeChildren.Add(v.GetOppositeGLTVertex()); } return IterationFlag.Continue; }); } else { List<MarkerVertex> qNeighbor = new List<MarkerVertex>(); ret.ForEachNeighbor(q, (v) => { qNeighbor.Add(v); return IterationFlag.Continue; }); ret.RemoveMarkerVertex(q); var qPrimeNeighbor = new System.Collections.Generic.HashSet<MarkerVertex>(); uPrime.ForEachNeighbor(qPrime, (v) => { qPrimeNeighbor.Add(v); return IterationFlag.Continue; }); uPrime.ForEachMarkerVertex((v) => { if (v != qPrime) { if (qPrimeNeighbor.Contains(v)) { HashSet<MarkerVertex> nSet = new HashSet<MarkerVertex>(qNeighbor); uPrime.ForEachNeighbor(v, (w) => { if (w != qPrime) nSet.Add(w); return IterationFlag.Continue; }); ret.AddMarkerVertex(v, nSet); } else { HashSet<MarkerVertex> nSet = new HashSet<MarkerVertex>(); uPrime.ForEachNeighbor(v, (w) => { if (w != qPrime) nSet.Add(w); return IterationFlag.Continue; }); ret.AddMarkerVertex(v, nSet); } } return IterationFlag.Continue; }); if (uPrime is PrimeNode) { uPrimeChildren.Add((uPrime as PrimeNode).childSetRepresentative); } else { uPrime.ForEachChild(v => { uPrimeChildren.Add(v); return IterationFlag.Continue; }, false); } } //union the children of uPrime for (int i = 0, n = uPrimeChildren.Count; i < n; ++i) { uPrimeChildren[i].parentLink = null; uPrimeChildren[i].unionFind_parent = representative; } //set deletion flag for uPrime, or if it's the child representative, make it a fake node uPrime.active = true; if (uPrime == representative) { uPrime.parentLink = ret;//update the parentLink to the new prime node //don't touch the unoinFind_parent field. leave it pointing to uPrime itself. } else//uPrime is not a fake node. { uPrime.parentLink = ret; //uPrime.unionFind_parent = null; } return ret; }
public void greedySolve() { timer = new Stopwatch(); timer.Start(); Route = new ArrayList(Cities.Length); System.Collections.Generic.HashSet<int> unvisitedIndexes = new System.Collections.Generic.HashSet<int>(); // using a city's index in Cities, we can interate through indexes that have yet to be added for (int index = 0; index < Cities.Length; index++) { unvisitedIndexes.Add(index); } print("\n\nTESTING\n"); City city; for (int i = 0; i < Cities.Length; i++) // keep trying start nodes until a solution is found { if (Route.Count == Cities.Length) { break; // DONE! } else { Route.Clear(); for (int index = 0; index < Cities.Length; index++) { unvisitedIndexes.Add(index); } city = Cities[i]; } for (int n = 0; n < Cities.Length; n++) // add nodes n times { double shortestDistance = Double.PositiveInfinity; int closestIndex = -1; foreach (int check in unvisitedIndexes) //find the closest city to add to route { double distance = city.costToGetTo(Cities[check]); if (distance < shortestDistance) { shortestDistance = distance; closestIndex = check; } } if (closestIndex != -1) { city = Cities[closestIndex]; Route.Add(city); unvisitedIndexes.Remove(closestIndex); } else { break; // try again } } } // call this the best solution so far. bssf is the route that will be drawn by the Draw method. bssf = new TSPSolution(Route); // update the cost of the tour. Program.MainForm.tbCostOfTour.Text = " " + bssf.costOfRoute(); TimeSpan ts = timer.Elapsed; Program.MainForm.tbElapsedTime.Text = ts.TotalSeconds.ToString(); // do a refresh. Program.MainForm.Invalidate(); }
private void VertexInsertion(SplitTree ST, List<int> sigma, int idx) { #region Bootstrapping if (ST.vertices.Count == 0)//initialization { Leaf v = new Leaf { id = sigma[idx], parent = null, }; ST.AddLeaf(v); ST.root = v; } else if (ST.vertices.Count == 1)//only the root, thus we cache the second vertex { Leaf v = new Leaf { id = sigma[idx], parent = null, }; ST.AddLeaf(v); } else if (ST.vertices.Count == 2)//now we're building the first trinity { Leaf v = new Leaf { id = sigma[idx], parent = null }; ST.AddLeaf(v); int missingConnection = -1; //test the missing connection between the cached 3 leave if (!storage[(ST.vertices[0] as Leaf).id].Contains((ST.vertices[1] as Leaf).id)) { missingConnection = 0; } else if (!storage[(ST.vertices[0] as Leaf).id].Contains((ST.vertices[2] as Leaf).id)) { missingConnection = 1; } else if (!storage[(ST.vertices[1] as Leaf).id].Contains((ST.vertices[2] as Leaf).id)) { missingConnection = 2; } MarkerVertex v1 = new MarkerVertex() { opposite = ST.vertices[0] }; MarkerVertex v2 = new MarkerVertex() { opposite = ST.vertices[1] }; MarkerVertex v3 = new MarkerVertex() { opposite = ST.vertices[2] }; (ST.vertices[0] as Leaf).opposite = v1; (ST.vertices[1] as Leaf).opposite = v2; (ST.vertices[2] as Leaf).opposite = v3; MarkerVertex center = null; switch (missingConnection) { case 0: center = v3; break; case 1: center = v2; break; case 2: center = v1; break; default: break; } var deg = new DegenerateNode() { parent = ST.vertices[0], Vu = new List<MarkerVertex> { v1, v2, v3 }, center = center, rootMarkerVertex = v1 }; v1.node = deg; ST.vertices[1].parent = ST.vertices[2].parent = deg; ST.vertices.Add(deg); ST.lastVertex = ST.vertices[2] as Leaf; } #endregion else { TreeEdge e; Vertex u; SplitTree tPrime; var returnType = SplitTree_CaseIdentification(ST, sigma, idx, out e, out u, out tPrime); switch (returnType) { case CaseIdentification_ResultType.SingleLeaf: //This case is not discussed in paper. However, if there's only a single leaf in neighbor set, //then a unique PE edge can be found. //Applying proposition 4.17, case 6 e.u = (u as Leaf).opposite; e.v = u; ST.SplitEdgeToStar(e, sigma[idx]); break; case CaseIdentification_ResultType.TreeEdge://PP or PE { bool unique = true; bool pp; //testing uniqueness, page 24 //check whether pp or pe if (!e.u.Perfect()) { var tmp = e.u; e.u = e.v; e.v = tmp; } pp = e.v.Perfect(); var u_GLT = e.u_GLT; var v_GLT = e.v_GLT; DegenerateNode degNode = null; if (u_GLT is DegenerateNode) degNode = u_GLT as DegenerateNode; if (v_GLT is DegenerateNode) degNode = v_GLT as DegenerateNode; if (degNode != null)//attached to a clique or a star { if ((pp && degNode.isClique) || (!pp/*pe*/ && degNode.isStar && (e.u == degNode.center || degNode.Degree(e.v as MarkerVertex) == 1))) { unique = false; } } if (unique) { //Proposition 4.17 case 5 or 6 if (pp)//PP { ST.SplitEdgeToClique(e, sigma[idx]); } else//PE { ST.SplitEdgeToStar(e, sigma[idx]); } } else { //Proposition 4.15, case 1 or 2 var deg = u_GLT; if (v_GLT is DegenerateNode) deg = v_GLT; ST.AttachToDegenerateNode(deg as DegenerateNode, sigma[idx]); } } break; case CaseIdentification_ResultType.HybridNode: if (u is DegenerateNode) { //Proposition 4.16 var uDeg = u as DegenerateNode; System.Collections.Generic.HashSet<MarkerVertex> PStar = new System.Collections.Generic.HashSet<MarkerVertex>(); System.Collections.Generic.HashSet<MarkerVertex> EStar = new System.Collections.Generic.HashSet<MarkerVertex>(); uDeg.ForEachMarkerVertex((v) => { if (v.perfect && v != uDeg.center) PStar.Add(v); else EStar.Add(v); return IterationFlag.Continue; }); //before we split, determine the new perfect states for the two new markers to be generated bool pp = false; if (uDeg.isStar && uDeg.center.perfect) { pp = true;//see figure 7. pp==true iff star and center is perfect. } var newNode = SplitNode(uDeg, PStar, EStar); ST.vertices.Add(newNode); //e.u \in PStar ; e.v \in EStar (thus containing the original center, if star) //PStar in uDeg; EStar in newNode if (newNode.parent == uDeg) { e.u = newNode.rootMarkerVertex.opposite; e.v = newNode.rootMarkerVertex; } else { e.u = uDeg.rootMarkerVertex; e.v = uDeg.rootMarkerVertex.opposite; } //assign perfect state values if (pp) { e.u.MarkAsPerfect(); e.v.MarkAsPerfect(); } else//PE, and PStar part always has an empty state and EStar part has perfect. { e.u.MarkAsEmpty(); e.v.MarkAsPerfect(); } //check whether pp or pe if (!e.u.Perfect()) { var tmp = e.u; e.u = e.v; e.v = tmp; } if (e.v.Perfect())//PP { ST.SplitEdgeToClique(e, sigma[idx]); } else//PE { ST.SplitEdgeToStar(e, sigma[idx]); } } else { //Proposition 4.15, case 3 ST.AttachToPrimeNode(u as PrimeNode, sigma[idx]); } break; case CaseIdentification_ResultType.FullyMixedSubTree: //Proposition 4.20 Cleaning(ST, tPrime); //ST.Debug(false); var contractionNode = Contraction(ST, tPrime, sigma[idx]); break; } } }
public void TestMemberFn_GetHashCode () { var hs1 = new System.Collections.Generic.HashSet<Matrix44>(); var hs2 = new System.Collections.Generic.HashSet<Int32>(); for(Int32 i = 0; i < 10000; ++i) { var a = GetNextRandomMatrix44 (); hs1.Add(a); hs2.Add(a.GetHashCode ()); } Assert.That(hs1.Count, Is.EqualTo(hs2.Count).Within(10)); }