static Hamming() { SortedSet <long> visited = new SortedSet <long>() { 1 }; SortedQueue queue = new SortedQueue(); queue.Push(1); int counted = 1; long next; for (int i = 0; i < N; i++) { Precalc[i] = queue.Pop(); for (int j = 0; j < Multipliers.Length; j++) { next = Precalc[i] * Multipliers[j]; if (!visited.Contains(next) && counted < N) { visited.Add(next); queue.Push(next); counted++; } } } }
public SortedQueue GetSortedQueue(List <Models.TransactionQueue> pendingTransactions, string sortedColumnName, int sortedDirection, int page, int pageSize) { //instance to hold values of anonymous type var sortedQueue = new SortedQueue(); //fetch data of priority rules var priorityRules = _priorityRules.GetPriorityRules(); //fetch values of smartsort Columns dynamically by priority rules, it can be more than 1 column //if smart sort columns are not defined set values of default column as TransactionPriorityOrder var listofSmartCol = SortColumns.GetSmartColumn(priorityRules.Result); //fetch data after making join pending transaction and priority rules var result = (from pt in pendingTransactions join pr in priorityRules.Result on pt.TranPriorityId equals pr.TransactionPriorityId //orderby //pt.Status descending, //pt.Type descending, //pr.TransactionPriorityOrder ascending, ////listofSmartCol, //pt.ReceivedDt ascending, //pt.ComponentNumber ascending select new TransactionQueueItems() { Id = pt.Id, PriorityName = pr.TransactionPriorityCode, TransactionPriorityOrder = pr.TransactionPriorityOrder, Quantity = pt.Quantity, Item = pt.Description, Location = pt.Location, Destination = pt.Destination, PatientName = pt.PatientName, Description = pt.Description, Color = pr.Color, Status = pt.Status, Type = pt.Type, ReceivedDT = pt.ReceivedDt, ComponentNumber = pt.ComponentNumber, Rack = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Rack), Shelf = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Shelf), Bin = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Bin), Slot = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Slot) } ) .ToList(); DoSmartSort smartSort = new DoSmartSort(); var sortedList = smartSort.OrderBySmartSort(result, listofSmartCol); if (page >= 1 && pageSize >= 1) { sortedList = sortedList.Skip((page - 1) * pageSize).Take(pageSize).ToList(); } sortedQueue.QueueList = sortedList; return(sortedQueue); }
public static IEnumerator FindPathAsync(SNode start, SNode goal, List <SNode> asyncPath) { openList = new SortedQueue <SNode>(); openList.Push(start); start.initialCost = 0.0f; start.estimatedCost = GetHeuristicEstimateCost(start, goal); start.nodeTotalCost = start.initialCost + start.estimatedCost; closedList = new HashSet <SNode>(); SNode sNode = null; while (openList.Length != 0) { sNode = openList.First; if (sNode.position == goal.position) { asyncPath = CalculatePath(sNode); } List <SNode> neighbors = new List <SNode>(); GridHandler.S.GetNeighbors(sNode, neighbors); for (int i = 0; i < neighbors.Count; i++) { SNode neighborNode = neighbors[i]; if (!closedList.Contains(neighborNode)) { neighborNode.estimatedCost = GetHeuristicEstimateCost(neighborNode, goal); neighborNode.initialCost = sNode.initialCost + 1; neighborNode.nodeTotalCost = neighborNode.estimatedCost + neighborNode.initialCost; neighborNode.parent = sNode; if (!openList.Contains(neighborNode)) { openList.Push(neighborNode); } } } closedList.Add(sNode); openList.Remove(sNode); //Debug.Log("iteration"); } yield return(null); //If finished looping and cannot find the goal then return null if (sNode.position != goal.position) { Debug.LogError("Goal Not Found"); asyncPath = null; } else { //Calculate the path based on the final node asyncPath = CalculatePath(sNode); } }
public TaskQueue(int workerCount) { taskQ = new SortedQueue<TaskItem>(TaskItemComparision); if (workerCount <= 0) throw new ArgumentException("workerCount mast greater than zero", "workerCount"); workers = new Thread[workerCount]; for (int i = 0; i < workerCount; i++) (workers[i] = new Thread(Consume)).Start(); }
public void Peek() { SortedQueue <int> q = new SortedQueue <int>(); q._list.AddRange(new int[] { 1, 1, 2 }); Assert.AreEqual(1, q.Peek()); CollectionAssert.AreEqual(new int[] { 1, 1, 2 }, q._list); }
public void Enqueue_NotNull() { SortedQueue <string> q = new SortedQueue <string>(); q.Enqueue(""); var q1 = new SortedQueue <int>(); q1.Enqueue(0); }
public void OnPMCompilerStopped(HelloCompiler.StopStatus status) { if (status == HelloCompiler.StopStatus.Finished) { if (CorrectSorting()) { PMWrapper.SetCaseCompleted(); } } SortedQueue.ResetQueues(); }
public TaskQueue(int workerCount) { taskQ = new SortedQueue <TaskItem>(TaskItemComparision); if (workerCount <= 0) { throw new ArgumentException("workerCount mast greater than zero", "workerCount"); } workers = new Thread[workerCount]; for (int i = 0; i < workerCount; i++) { (workers[i] = new Thread(Consume)).Start(); } }
public void ForEach() { SortedQueue <int> q = new SortedQueue <int>(); q._list.AddRange(new int[] { 0, 1, 1, 2 }); List <int> result = new List <int>(); foreach (var item in q) { result.Add(item); } CollectionAssert.AreEqual(new int[] { 0, 1, 1, 2 }, result); }
public void Enqueue() { SortedQueue <int> q = new SortedQueue <int>(); q.Enqueue(1); q.Enqueue(3); q.Enqueue(2); CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, q._list); q = new SortedQueue <int>(); q.Enqueue(new int[] { 1, 2, 2, 3, 0, -1 }); CollectionAssert.AreEqual(new int[] { -1, 0, 1, 2, 2, 3 }, q._list); }
public void OnPMCompilerStopped(HelloCompiler.StopStatus status) { if (status == HelloCompiler.StopStatus.Finished) { if (CarsSorted < carsToSort) { PMWrapper.RaiseTaskError("Alla varor sorterades inte."); } else if (CorrectSorting()) { PMWrapper.SetCaseCompleted(); } } SortedQueue.ResetQueues(); }
//Summary StoryId <> Default Sort Functionality by ReceivedDT public void Test_DefaultSorting_OrderByReceivedDT(DateTime ReceivedDT1, DateTime ReceivedDT2, DateTime ReceivedDT3) { var tq = new Mock <ITransactionQueueRepository>(); var tp = new Mock <IPriorityRules>(); var mock = new Mock <ISortStrategy>(); //var ISA = new Mock<List<int?>>(); string sortedColumnName = "PatientName"; int sortedDirection = 1; int page = 1; int pageSize = 10; TestDataGeneratorSortStrategy testDataGenerator = new TestDataGeneratorSortStrategy(); var transactionQueueEntities = testDataGenerator.GetTransactionQueueEntitybyReceivedDT(); var transactionPriorities = testDataGenerator.GetTransactionPriorityEntity(); //tq.Setup(x => x.GetTransactionsByISAId(ISA.Object)).Returns(transactionQueueEntities); tp.Setup(x => x.GetPriorityRules()).Returns(transactionPriorities); ISortStrategy tranQueueData = new ColumnSorting(tp.Object, tq.Object); SortedQueue sortedqueue = tranQueueData.GetSortedQueue(transactionQueueEntities, sortedColumnName, sortedDirection, page, pageSize); Assert.Equal(ReceivedDT1, sortedqueue.QueueList[0].ReceivedDT); Assert.Equal(ReceivedDT2, sortedqueue.QueueList[1].ReceivedDT); Assert.Equal(ReceivedDT3, sortedqueue.QueueList[2].ReceivedDT); }
//Summary StoryId <> Default Sort Functionality by Status and Type public void Test_DefaultSorting_OrderBySmartColLocation(string PatientName1, string PatientName2, string PatientName3) { var tq = new Mock <ITransactionQueueRepository>(); var tp = new Mock <IPriorityRules>(); var mock = new Mock <ISortStrategy>(); //var ISA = new Mock<List<int?>>(); string sortedColumnName = string.Empty; int sortedDirection = 1; int page = 1; int pageSize = 10; TestDataGeneratorQueueFilter testDataGenerator = new TestDataGeneratorQueueFilter(); var transactionQueueEntities = testDataGenerator.GetTransactionQueueEntityByColumn(); var transactionPriorities = testDataGenerator.GetTransactionPriorityEntity(); //tq.Setup(x => x.GetTransactionsByISAId(ISA.Object)).Returns(transactionQueueEntities); tp.Setup(x => x.GetPriorityRules()).Returns(transactionPriorities); IQueueFilter queueFilter = new QueueFilter(tp.Object, tq.Object); SortedQueue sortedqueue = queueFilter.GetAllSortedTransaction(transactionQueueEntities, sortedColumnName, sortedDirection, page, pageSize); Assert.Equal(PatientName1, sortedqueue.QueueList[0].Location); Assert.Equal(PatientName2, sortedqueue.QueueList[1].Location); Assert.Equal(PatientName3, sortedqueue.QueueList[2].Location); }
//Summary StoryId <> Default Sort Functionality by PatientName public void Test_SmartSorting_OrderByPatientName(string patient1, string patient2, string patient3) { var tq = new Mock <ITransactionQueueRepository>(); var tp = new Mock <IPriorityRules>(); var mock = new Mock <ISortStrategy>(); //var ISA = new Mock<List<int?>>(); string sortedColumnName = null; int sortedDirection = 1; int page = 1; int pageSize = 10; TestDataGeneratorSortStrategy testDataGenerator = new TestDataGeneratorSortStrategy(); var transactionQueueEntities = testDataGenerator.GetTransactionQueueEntityBySmartColumn(); var transactionPriorities = testDataGenerator.GetTransactionPriorityEntityByPatientName(); //tq.Setup(x => x.GetTransactionsByISAId(ISA.Object)).Returns(transactionQueueEntities); tp.Setup(x => x.GetPriorityRules()).Returns(transactionPriorities); SmartSorting tranQueueData = new SmartSorting(tp.Object, tq.Object); SortedQueue sortedqueue = tranQueueData.GetSortedQueue(transactionQueueEntities, sortedColumnName, sortedDirection, page, pageSize); Assert.Equal(patient1, sortedqueue.QueueList[0].PatientName); Assert.Equal(patient2, sortedqueue.QueueList[1].PatientName); Assert.Equal(patient3, sortedqueue.QueueList[2].PatientName); }
public void Init() { _queue = new SortedQueue <CreatedTimeTagedObject <EmptyTestClass> >(); }
public void Enqueue_Null() { SortedQueue <string> q = new SortedQueue <string>(); q.Enqueue((string)null); }
// Use this for initialization public void Awake() { Instance = this; tasks = new SortedQueue <float, Task>(false); }
public void Cleanup() { _queue.Clear(); _queue = null; }
private Planing(SortedQueue <double, StateAction> priorityQueue, Planing other) { this.priorityQueue = priorityQueue; updateValues = other.updateValues; getPriority = other.getPriority; }
public static List <SNode> FindPath(SNode start, SNode goal) { if (goal.bObstacle) { return(null); } IsCalculating = true; openList = new SortedQueue <SNode>(); openList.Push(start); start.initialCost = 0.0f; start.estimatedCost = GetHeuristicEstimateCost(start, goal); start.nodeTotalCost = start.initialCost + start.estimatedCost; closedList = new HashSet <SNode>(); SNode sNode = null; while (openList.Length != 0) { sNode = openList.First; if (sNode == null) { IsCalculating = false; return(null); } if (sNode.position == goal.position) { List <SNode> newPath = CalculatePath(sNode); IsCalculating = false; return(newPath); } List <SNode> neighbors = new List <SNode>(); GridHandler.S.GetNeighbors(sNode, neighbors); for (int i = 0; i < neighbors.Count; i++) { SNode neighborNode = neighbors[i]; if (!closedList.Contains(neighborNode)) { neighborNode.estimatedCost = GetHeuristicEstimateCost(neighborNode, goal); neighborNode.initialCost = sNode.initialCost + 1; neighborNode.nodeTotalCost = neighborNode.estimatedCost + neighborNode.initialCost; neighborNode.parent = sNode; if (!openList.Contains(neighborNode)) { openList.Push(neighborNode); } } } if (sNode == null) { return(null); } closedList.Add(sNode); openList.Remove(sNode); } //If finished looping and cannot find the goal then return null if (sNode.position != goal.position) { Debug.LogError("Goal Not Found"); IsCalculating = false; return(null); } //Calculate the path based on the final node List <SNode> Path = CalculatePath(sNode); IsCalculating = false; return(Path); }
public SortedQueue GetSortedQueue(List <Models.TransactionQueue> pendingTransactions, string sortedColumnName, int sortedDirection, int page, int pageSize) { //fetch column name dynamically var ColumnName = typeof(TransactionQueueItems).GetProperty(sortedColumnName); //var ColumnNameBySortDir = SortColumns.GetDefaultColumn(sortedColumnName, sortedDirection); //instance to hold values of anonymous type var sortedQueue = new SortedQueue(); //fetch data of priority rules var priorityRules = _priorityRules.GetPriorityRules(); //fetch data by doing join var sortedList = (from pt in pendingTransactions join pr in priorityRules.Result on pt.TranPriorityId equals pr.TransactionPriorityId //orderby //pt.Status descending, //pt.Type descending, ////ColumnNameBySortDir, //pt.ReceivedDT ascending select new TransactionQueueItems() { Id = pt.Id, PriorityName = pr.TransactionPriorityCode, TransactionPriorityOrder = pr.TransactionPriorityOrder, Quantity = pt.Quantity, Item = pt.Description, Location = pt.Location, Destination = pt.Destination, PatientName = pt.PatientName, Description = pt.Description, Color = pr.Color, Status = pt.Status, Type = pt.Type, ReceivedDT = pt.ReceivedDt, ComponentNumber = pt.ComponentNumber, Rack = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Rack), Shelf = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Shelf), Bin = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Bin), Slot = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Slot) } ) .ToList(); if (sortedDirection == 1) { sortedList = sortedList.OrderByDescending(pt => pt.Status) .ThenByDescending(pt => pt.Type) .ThenByDescending(col => ColumnName.GetValue(col, null)) .ThenBy(pr => pr.ReceivedDT) .ToList(); } else { sortedList = sortedList.OrderByDescending(pt => pt.Status) .ThenByDescending(pt => pt.Type) .ThenBy(col => ColumnName.GetValue(col, null)) .ThenBy(pr => pr.ReceivedDT) .ToList(); } if (page >= 1 && pageSize >= 1) { sortedList = sortedList.Skip((page - 1) * pageSize).Take(pageSize).ToList(); } sortedQueue.QueueList = sortedList; return(sortedQueue); }
static Scheduler() { ScheduleTimer = new Timer(Callback, null, Timeout.Infinite, Timeout.Infinite); Tasks = new SortedQueue <Task>(); }
public void Init() { _queue = new SortedQueue <int>(); }