public void TestDecPriority() { PairingHeap <Plane, int> queue = new PairingHeap <Plane, int>(); int idCounter = 0; Plane plane1 = new Plane(); plane1.SetInternationalID("id" + idCounter); idCounter++; plane1.SetPriority(4); queue.Add(plane1); Plane plane2 = new Plane(); plane2.SetInternationalID("id" + idCounter); idCounter++; plane2.SetPriority(5); queue.Add(plane2); Plane plane3 = new Plane(); plane3.SetInternationalID("id" + idCounter); idCounter++; plane3.SetPriority(7); queue.Add(plane3); queue.ChangePriority(plane2, 89); File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\testDecPriority.txt", queue.TraverseLevelOrder()); }
/// <summary> /// Gets the minimum-weight path to a goal using the A* algorithm. /// </summary> /// <remarks>Because the heuristic is not known to be consistent, we cannot use the closed set optimization.</remarks> /// <typeparam name="TNode">The type of a node.</typeparam> /// <typeparam name="TKey">The type of a node key.</typeparam> /// <param name="sources">The set of nodes from which to start the search, weighted by their initial cost.</param> /// <param name="key">The function which maps a node to its key.</param> /// <param name="next">The function which maps a node to its adjacent nodes.</param> /// <param name="goal">The goal predicate.</param> /// <param name="heuristic">The possibly-inconsistent heuristic function.</param> /// <returns>The minimum-weight path, or null if none exists.</returns> private static IWeighted <IEnumerable <TNode> > AStarInconsistent <TNode, TKey>( IEnumerable <IWeighted <TNode> > sources, Func <TNode, TKey> key, Func <TNode, IEnumerable <IWeighted <TNode> > > next, Func <TNode, bool> goal, Func <TNode, double> heuristic) { var came_from = new Dictionary <TKey, TNode>(); IPriorityQueue <double, AStarOpen <TNode> > open_queue = new PairingHeap <double, AStarOpen <TNode> >(); var open_lookup = new Dictionary <TKey, IPriorityQueueHandle <double, AStarOpen <TNode> > >(); foreach (var source in sources) { var u = source.Value; var key_u = key(u); var g_u = source.Weight; var f_u = g_u + heuristic(u); var open_u = new AStarOpen <TNode>(u, g_u); open_u.Handle = open_queue.Add(f_u, open_u); open_lookup.Add(key_u, open_u.Handle); } while (open_queue.Count > 0) { var handle_u = open_queue.Min; var u = handle_u.Value.Node; var key_u = key(u); if (goal(u)) { var path = ReconstructPath(key, came_from, u); return(new Weighted <IEnumerable <TNode> >(path, handle_u.Value.G)); } open_queue.Remove(handle_u); open_lookup.Remove(key_u); foreach (var uv in next(u)) { var v = uv.Value; var key_v = key(v); var g_v = handle_u.Value.G + uv.Weight; var f_v = g_v + heuristic(v); IPriorityQueueHandle <double, AStarOpen <TNode> > handle_v; if (open_lookup.TryGetValue(key_v, out handle_v)) { if (f_v < handle_v.Key) { open_queue.UpdateKey(handle_v, f_v); handle_v.Value.G = g_v; came_from[key_v] = u; } } else { var open_v = new AStarOpen <TNode>(v, g_v); open_v.Handle = open_queue.Add(f_v, open_v); open_lookup.Add(key_v, open_v.Handle); came_from[key_v] = u; } } } return(null); }
/// <summary> /// Gets the minimum-weight path to a goal using uniform cost search. /// </summary> /// <typeparam name="TNode">The type of a node.</typeparam> /// <typeparam name="TKey">The type of a node key.</typeparam> /// <param name="sources">The set of nodes from which to start the search, weighted by their initial cost.</param> /// <param name="key">The function which maps a node to its key.</param> /// <param name="next">The function which maps a node to its adjacent nodes.</param> /// <param name="goal">The goal predicate.</param> /// <returns>The minimum-weight path, or null if none exists.</returns> public static IWeighted <IEnumerable <TNode> > UniformCostSearch <TNode, TKey>( this IEnumerable <IWeighted <TNode> > sources, Func <TNode, TKey> key, Func <TNode, IEnumerable <IWeighted <TNode> > > next, Func <TNode, bool> goal) { var came_from = new Dictionary <TKey, TNode>(); var open_lookup = new Dictionary <TKey, IPriorityQueueHandle <double, TNode> >(); IPriorityQueue <double, TNode> open_queue = new PairingHeap <double, TNode>(); var closed = new HashSet <TKey>(); foreach (var source in sources) { var u = source.Value; var g_u = source.Weight; open_lookup.Add(key(u), open_queue.Add(g_u, u)); } while (open_queue.Count > 0) { var handle_u = open_queue.Min; var u = handle_u.Value; var key_u = key(u); var g_u = handle_u.Key; if (goal(u)) { var path = ReconstructPath(key, came_from, u); return(new Weighted <IEnumerable <TNode> >(path, g_u)); } open_lookup.Remove(key_u); open_queue.Remove(handle_u); closed.Add(key_u); foreach (var uv in next(u)) { var v = uv.Value; var key_v = key(v); if (closed.Contains(key_v)) { continue; } IPriorityQueueHandle <double, TNode> v_handle; var g_uv = g_u + uv.Weight; if (open_lookup.TryGetValue(key_v, out v_handle)) { if (g_uv < v_handle.Key) { open_queue.UpdateKey(v_handle, g_uv); came_from[key_v] = u; } } else { open_lookup.Add(key_v, open_queue.Add(g_uv, v)); came_from[key_v] = u; } } } return(null); }
public void return_correct_min_element_and_keep_it_in_heap_on_findmin_operation() { _heap.Add(9); _heap.Add(7); _heap.Add(5); _heap.Add(3); Assert.That(_heap.FindMin(), Is.EqualTo(3)); Assert.That(_heap.Count, Is.EqualTo(4)); }
public void StartMessage(OutstandingMessage message, DateTime expires) { var found = _outstandingRequests.ContainsKey(message.EventId); _outstandingRequests[message.EventId] = message; if (!found) { _bySequences.Add(message.ResolvedEvent.OriginalEventNumber, message.ResolvedEvent.OriginalEventNumber); _byTime.Add(new RetryableMessage(message.EventId, expires)); } }
public void Handle(AuthenticatedHttpRequestMessage message) { var manager = message.Manager; var match = message.Match; try { var reqParams = match.RequestHandler(manager, match.TemplateMatch); if (!reqParams.IsDone) { _pending.Add(Tuple.Create(DateTime.UtcNow + reqParams.Timeout, manager)); } } catch (Exception exc) { Log.Error(exc, "Error while handling HTTP request '{url}'.", manager.HttpEntity.Request.Url); InternalServerError(manager); } PurgeTimedOutRequests(); }
private void FindPaths() { var frontier = new PairingHeap <double, Location>(new DoubleComparer()) { { 0, HeroLocation } }; CategorizeObject(ObjectMap[HeroLocation]); while (frontier.Count != 0) { var current = frontier.Pop().Value; for (var d = Direction.Up; d <= Direction.RightDown; d++) { var next = current.NeighborAt(d); if (IsEnemySpawn(next) || !ObjectMap.ContainsKey(next)) { continue; } var mapObject = ObjectMap[next]; CategorizeObject(mapObject); var nextTime = TravelTimes[current] + 0.5 * movementCost[mapObject.Terrain]; if (TravelTimes.ContainsKey(next) && !(nextTime < TravelTimes[next])) { continue; } TravelTimes[next] = nextTime; if (IsPassable(mapObject)) { frontier.Add(nextTime, next); } previousLocation[next] = current; } } }
private void ProcessRequest(HttpService httpService, HttpEntity httpEntity) { var request = httpEntity.Request; try { var allMatches = httpService.GetAllUriMatches(request.Url); if (allMatches.Count == 0) { NotFound(httpEntity); return; } var allowedMethods = GetAllowedMethods(allMatches); if (request.HttpMethod.Equals(HttpMethod.Options, StringComparison.OrdinalIgnoreCase)) { RespondWithOptions(httpEntity, allowedMethods); return; } var match = allMatches.LastOrDefault( m => m.ControllerAction.HttpMethod.Equals(request.HttpMethod, StringComparison.OrdinalIgnoreCase)); if (match == null) { MethodNotAllowed(httpEntity, allowedMethods); return; } ICodec requestCodec = null; var supportedRequestCodecs = match.ControllerAction.SupportedRequestCodecs; if (supportedRequestCodecs != null && supportedRequestCodecs.Length > 0) { requestCodec = SelectRequestCodec(request.HttpMethod, request.ContentType, supportedRequestCodecs); if (requestCodec == null) { BadContentType(httpEntity, "Invalid or missing Content-Type"); return; } } ICodec responseCodec = SelectResponseCodec(request.QueryString, request.AcceptTypes, match.ControllerAction.SupportedResponseCodecs, match.ControllerAction.DefaultResponseCodec); if (responseCodec == null) { BadCodec(httpEntity, "Requested URI is not available in requested format"); return; } try { var manager = httpEntity.CreateManager(requestCodec, responseCodec, allowedMethods, satisfied => { }); var reqParams = match.RequestHandler(manager); if (!reqParams.IsDone) { _pending.Add(Tuple.Create(DateTime.UtcNow + reqParams.Timeout, manager)); } } catch (Exception exc) { Log.ErrorException(exc, "Error while handling HTTP request '{url}'.", request.Url); InternalServerError(httpEntity); } } catch (Exception exc) { Log.ErrorException(exc, "Unhandled exception while processing HTTP request at [{listenPrefixes}].", string.Join(", ", httpService.ListenPrefixes)); InternalServerError(httpEntity); } PurgeTimedOutRequests(); }
public void TestAllOperationsOnRandomNumbers() { int count = 10000; //MIN IS 100 int idCounter = 1; List <Plane> planes = new List <Plane>(count); List <Plane> removed = new List <Plane>(count); PairingHeap <Plane, int> queue = new PairingHeap <Plane, int>(); Random random = new Random(); int addCount = 0, succAddCount = 0, changePriorityCount = 0, succChangePriorityCount = 0, deleteCount = 0, succDeleteCount = 0, compareCheck = 0; String history = ""; int deleteFileNumber = 1; for (int i = 0; i < count; i++) { int number = random.Next(0, 100 * count); if (number % 5 == 0 || number % 5 == 3 || number % 5 == 4) { addCount++; Plane newPlane = new Plane(); newPlane.SetInternationalID("id" + idCounter); idCounter++; newPlane.SetPriority(random.Next(11)); if (queue.Add(newPlane)) { succAddCount++; history += "ADDED: " + newPlane.GetInternationalID() + " with priority " + newPlane.GetPriority() + "\r\n"; history += "ROOT: " + queue.Root.Data.GetInternationalID() + " with priority " + queue.Root.Data.GetPriority() + "\r\n"; planes.Add(newPlane); } } else if (number % 5 == 1 || number % 5 == 2) { deleteCount++; if (planes.Count > 0) { Plane toDelete = queue.DeleteMin(); if (toDelete != null) { history += "" + toDelete.GetInternationalID() + "\r\n"; succDeleteCount++; planes.Remove(toDelete); removed.Add(toDelete); history += "DELETED: " + toDelete.GetInternationalID() + " with priority " + toDelete.GetPriority() + "\r\n"; if (queue.Root != null) { history += "ROOT: " + queue.Root.Data.GetInternationalID() + " with priority " + queue.Root.Data.GetPriority() + "\r\n"; } else { history += "EMPTY HEAP\r\n"; } } } if (removed.Count > 0) { Plane errorneousPlane = queue.Delete(removed[random.Next(0, removed.Count)]); // SHOULD DO NOTHING if (errorneousPlane != null) { history += "???DELETED: " + errorneousPlane.GetInternationalID() + " with priority " + errorneousPlane.GetPriority() + "\r\n"; if (queue.Root != null) { history += "ROOT: " + queue.Root.Data.GetInternationalID() + " with priority " + queue.Root.Data.GetPriority() + "\r\n"; } else { history += "EMPTY HEAP\r\n"; } } } } if (count >= 100 && number % 100 == 0) { changePriorityCount++; if (planes.Count > 0) { int newPriority = random.Next(11); int randomIndex = random.Next(0, planes.Count); if (newPriority != planes[randomIndex].GetPriority()) { Assert.IsTrue(queue.ChangePriority(planes[randomIndex], newPriority)); planes[randomIndex].SetPriority(newPriority); succChangePriorityCount++; } } if (removed.Count > 0) { int newPriority = random.Next(11); int randomIndex = random.Next(0, removed.Count); if (newPriority != removed[randomIndex].GetPriority()) { Assert.IsFalse(queue.ChangePriority(removed[randomIndex], newPriority)); } } if (planes.Count > 0) { int randomIndex = random.Next(0, planes.Count); Plane randomDelete = queue.Delete(planes[randomIndex]); if (randomDelete != null) { planes.RemoveAt(randomIndex); removed.Add(randomDelete); } deleteFileNumber++; } compareCheck++; File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\pairingheapTestHistory.txt", history); foreach (Plane plane in planes) { Assert.IsTrue(queue.Contains(plane)); } foreach (Plane plane in removed) { Assert.IsFalse(queue.Contains(plane)); } } } String treeTraversalLevelOrder = queue.TraverseLevelOrder(); File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\pairingheapTestLevelOrder.txt", treeTraversalLevelOrder); String treeTraversalInOrder = queue.TraverseInOrder(); File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\pairingheapTestInOrder.txt", treeTraversalInOrder); String checkInfo = "ADD checks: " + addCount + "\r\nSuccessfully added elements: " + succAddCount + "\r\nCHANGE PRIORITY checks: " + changePriorityCount + "\r\nSuccessfully changed priorities: " + succChangePriorityCount + "\r\nDELETE checks: " + deleteCount + "\r\nSuccessfully deleted elements: " + succDeleteCount + "\r\nQueue-List comparisons: " + compareCheck; File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\pairingheapTestStats.txt", checkInfo); File.WriteAllText("D:\\.NET Projects\\PlaneDepartureTracking\\PlaneDepartureTrackingMSTest\\pairingheapTestHistory.txt", history); }
public IEnumerable<Tuple<Word, int>> Derive() { var derivedWords = new HashSet<string>(); var pq = new PairingHeap<Word, int>(); pq.Add(new Word(Grammar.StartSymbol), 0); var rules = Grammar.Rules.OrderBy(r => r.WordToInsert.Length - r.WordToReplace.Length).ToArray(); while (pq.Count > 0) { var elementToDerive = pq.Min; pq.Remove(elementToDerive); var wordToDerive = elementToDerive.Key; foreach (var nw in rules.SelectMany(rule => wordToDerive.ReplaceAll(rule.WordToReplace, rule.WordToInsert)) .Where(nw => !derivedWords.Contains(nw.ToString()))) { derivedWords.Add(nw.ToString()); pq.Add(nw, nw.Length); yield return Tuple.Create(nw, wordToDerive.Length); } } }