public ActionResult Table(string sortOrder = "Asc", string sortBy = "" /*, string dynamicSortOrder = "Asc", string dynamicSortBy = ""*/) { try { var userInfoEntities = _userInfoServices.GetAll(); if (userInfoEntities == null) { return(View("Error", new HandleErrorInfo(new NullReferenceException(), "PlayoffUserInfo", "Table"))); } userInfoEntities = userInfoEntities.OrderByDescending(u => u.I_Points); userInfoEntities = userInfoEntities.ToList(); // avoid multiple enumeration ViewBag.BestDay = _userInfoServices.GetTopBestDay(); ViewBag.BestMonth = _userInfoServices.GetTopBestMonth(); ViewBag.BestPtsLastD = userInfoEntities.OrderByDescending(u => u.I_PtLastD).First(); ViewBag.SortOrder = sortOrder;//(sortOrder == "Asc" ? "Desc" : "Asc"); if (!string.IsNullOrEmpty(sortBy)) { return(View(SortUtility.SortUserInfoTable(userInfoEntities, sortBy, sortOrder))); } return(View(userInfoEntities)); } catch (Exception e) { return(View("Error", new HandleErrorInfo(e, "PlayoffUserInfo", "Table"))); } }
public void KeyValueSort(float[] keys) { int[] values = keys.Select(k => (int)(k * 1000)).ToArray(); SortUtility.Sort(keys, values.AsSpan()); VerifySorted(keys, values); }
// would be used with partial public ActionResult SortUndrafted(string sortOrder, string sortBy) { var undrafted = _playerInfoServices.GetUndrafted().ToList(); ViewBag.SortOrder = sortOrder; //ViewBag.SortBy = sortBy; return(PartialView("_undraftedGrid", SortUtility.SortPlayerInfoTable(undrafted, sortBy, sortOrder))); }
public void Sort(float[] data) { float[] expected = data.ToArray(); Array.Sort(expected); SortUtility.Sort(data); Assert.Equal(expected, data); }
public void SortSlice() { float[] data = { 3, 2, 1, 0, -1 }; Span <float> slice = data.AsSpan(1, 3); SortUtility.Sort(slice); float[] actual = slice.ToArray(); float[] expected = { 0, 1, 2 }; Assert.Equal(actual, expected); }
private static IEnumerable Sort(IEnumerable collection, string sortExpression) { string propertyName = sortExpression; bool reverse = false; if (propertyName.EndsWith("DESC")) { reverse = true; propertyName = propertyName.Substring(0, propertyName.Length - 5); } return(SortUtility.Sort(collection, propertyName, reverse)); }
public ActionResult PoolerProfile(string userEmail, string displayName = "", string sortOrder = "Asc", string sortBy = "") { if (string.IsNullOrEmpty(userEmail)) { return(View("Error", new HandleErrorInfo(new Exception("Malformed Request string param: userEmail"), "PlayoffUserInfo", "PoolerProfile"))); } try { var poolerChoices = _playerInfoServices.GetAllWhere(userEmail); if (poolerChoices == null) { return(View("Error", new HandleErrorInfo(new NullReferenceException(), "PlayoffUserInfo", "PoolerProfile"))); } var userInfo = _userInfoServices.GetByEmail(userEmail); if (userInfo == null) { return(View("Error", new HandleErrorInfo(new NullReferenceException(), "PlayoffUserInfo", "PoolerProfile"))); } ViewBag.DisplayName = displayName; ViewBag.UserEmail = userEmail; ViewBag.Pic = userInfo.C_Pic; ViewBag.BestDay = userInfo.I_BestDay; ViewBag.BestDayDate = userInfo.D_BestDay; ViewBag.BestMonth = userInfo.I_BestMonth; ViewBag.BestMonthDate = userInfo.D_BestMonth; ViewBag.PtsLastD = userInfo.I_PtLastD; //ViewBag.UserInfo = userInfo; ViewBag.SortOrder = sortOrder;//(sortOrder == "Asc" ? "Desc" : "Asc"); if (!string.IsNullOrEmpty(sortBy)) { return(View(SortUtility.SortPlayerInfoTable(poolerChoices, sortBy, sortOrder))); } return(View(poolerChoices.OrderBy(p => p.I_Round))); } catch (Exception e) { return(View("Error", new HandleErrorInfo(e, "PlayerInfo", "Undrafted"))); } }
/// <inheritdoc /> public int FindIntersections(PointF start, PointF end, Span <PointF> buffer, IntersectionRule intersectionRule) { this.EnsureInternalPathsInitalized(); int totalAdded = 0; InternalPath.PointOrientation[] orientations = ArrayPool <InternalPath.PointOrientation> .Shared.Rent(buffer.Length); // the largest number of intersections of any sub path of the set is the max size with need for this buffer. Span <InternalPath.PointOrientation> orientationsSpan = orientations; try { foreach (var ip in this.internalPaths) { Span <PointF> subBuffer = buffer.Slice(totalAdded); Span <InternalPath.PointOrientation> subOrientationsSpan = orientationsSpan.Slice(totalAdded); var position = ip.FindIntersectionsWithOrientation(start, end, subBuffer, subOrientationsSpan); totalAdded += position; } Span <float> distances = stackalloc float[totalAdded]; for (int i = 0; i < totalAdded; i++) { distances[i] = Vector2.DistanceSquared(start, buffer[i]); } var activeBuffer = buffer.Slice(0, totalAdded); var activeOrientationsSpan = orientationsSpan.Slice(0, totalAdded); SortUtility.Sort(distances, activeBuffer, activeOrientationsSpan); if (intersectionRule == IntersectionRule.Nonzero) { totalAdded = InternalPath.ApplyNonZeroIntersectionRules(activeBuffer, activeOrientationsSpan); } } finally { ArrayPool <InternalPath.PointOrientation> .Shared.Return(orientations); } return(totalAdded); }
static void Run(List <Employee> employeeList, int population) { SetEmployeeInfo(employeeList, population); //Show default Empolyees Console.WriteLine("Default Empolyees"); Show(employeeList); SortUtility.QuickSort(employeeList); //IComparable Id Ascend Console.WriteLine("ID ASCEND"); Show(employeeList); AgeAscendComparer aac = new AgeAscendComparer(); //IComparer Age Ascend SortUtility.QuickSort(employeeList, aac); Console.WriteLine("AGE ASCEND"); Show(employeeList); SortUtility.QuickSort(employeeList, EmployeeComparison.SalaryAscendComparison); //IComparison Salary Ascend Console.WriteLine("SALARY ASCEND"); Show(employeeList); }
public void ThrowsOnMissingDependency() { var unsorted = new List <List <string> >() { new List <string>() { "A" }, new List <string>() { "B", "C", "E" }, new List <string>() { "C" }, new List <string>() { "D", "A" }, new List <string>() { "E", "D", "G" }, new List <string>() { "F", "Z" }, // let's miss Z new List <string>() { "G", "F", "H" }, new List <string>() { "H" }, }; Assert.Throws <ArgumentException>(() => SortUtility.TopoSort(unsorted).ToArray()); }
public ActionResult LeagueLeaders(string sortOrder = "Asc", string sortBy = "") { try { var leagueLeaders = _playerInfoServices.GetLeagueLeaders(); if (leagueLeaders == null) { return(View("Error", new HandleErrorInfo(new NullReferenceException(), "PlayerInfo", "LeagueLeaders"))); } ViewBag.SortOrder = sortOrder;//(sortOrder == "Asc" ? "Desc" : "Asc"); if (!string.IsNullOrEmpty(sortBy)) { return(View(SortUtility.SortPlayerInfoTable(leagueLeaders, sortBy, sortOrder))); } return(View(leagueLeaders)); } catch (Exception e) { return(View("Error", new HandleErrorInfo(e, "PlayerInfo", "LeagueLeaders"))); } }
public ActionResult Undrafted(string sortOrder = "Asc", string sortBy = "") { try { var undrafted = _playerInfoServices.GetUndrafted(); if (undrafted == null) { return(View("Error", new HandleErrorInfo(new NullReferenceException(), "PlayerInfo", "Undrafted"))); } ViewBag.SortOrder = sortOrder;//(sortOrder == "Asc" ? "Desc" : "Asc"); if (!string.IsNullOrEmpty(sortBy)) { return(View(SortUtility.SortPlayerInfoTable(undrafted, sortBy, sortOrder))); } return(View(undrafted)); } catch (Exception e) { return(View("Error", new HandleErrorInfo(e, "PlayerInfo", "Undrafted"))); } }
public static int[] RandomIndex(int InMin, int InMax, int InCount) { int length = InMax - InMin; Assert.IsTrue(length >= InCount); int[] array = new int[length]; for (int i = 0; i < length; i++) { array[i] = InMin + i; } int[] result = new int[InCount]; for (int i = 0; i < InCount; i++) { int index = Random.Range(0, length); result[i] = array[index]; array[index] = array[length - 1]; --length; } return(SortUtility.BubbleSort(result)); }
public void CanSortDependency() { var a = new DependencyItem <string>("A"); var b = new DependencyItem <string>("B", "C", "E"); var c = new DependencyItem <string>("C"); var d = new DependencyItem <string>("D", "A"); var e = new DependencyItem <string>("E", "D", "G"); var f = new DependencyItem <string>("F"); var g = new DependencyItem <string>("G", "F", "H"); var h = new DependencyItem <string>("H"); var unsorted = new[] { a, b, c, d, e, f, g, h }; var expected = new[] { a, c, d, f, h, g, e, b }; var actual = SortUtility.TopoSort(unsorted, x => x.Name, y => y.Dependencies).ToArray(); var actual2 = SortUtility.TopoSort(unsorted).ToArray(); for (int i = 0; i < expected.Length; i++) { Assert.Equal(expected[i].Name, actual[i].Name); Assert.Equal(expected[i].Name, actual2[i].Name); } }
/// <summary> /// Based on a line described by <paramref name="start" /> and <paramref name="end" /> /// populates a buffer for all points on the path that the line intersects. /// </summary> /// <param name="start">The start.</param> /// <param name="end">The end.</param> /// <param name="buffer">The buffer.</param> /// <param name="orientationsSpan">The buffer for storeing the orientation of each intersection.</param> /// <returns>number of intersections hit</returns> public int FindIntersectionsWithOrientation(PointF start, PointF end, Span <PointF> buffer, Span <PointOrientation> orientationsSpan) { if (this.points.Length < 2) { return(0); } int count = buffer.Length; this.ClampPoints(ref start, ref end); var target = new Segment(start, end); int polyCorners = this.points.Length; if (!this.closedPath) { polyCorners -= 1; } int position = 0; Vector2 lastPoint = MaxVector; PassPointData[] precaclulate = ArrayPool <PassPointData> .Shared.Rent(this.points.Length); Span <PassPointData> precaclulateSpan = precaclulate.AsSpan(0, this.points.Length); try { // pre calculate relative orientations X places ahead and behind Vector2 startToEnd = end - start; PointOrientation prevOrientation = CalulateOrientation(startToEnd, this.points[polyCorners - 1].Point - end); PointOrientation nextOrientation = CalulateOrientation(startToEnd, this.points[0].Point - end); PointOrientation nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[1].Point - end); // iterate over all points and precalculate data about each, pre cacluating it relative orientation for (int i = 0; i < polyCorners && count > 0; i++) { ref Segment edge = ref this.points[i].Segment; // shift all orientations along but one place and fill in the last one PointOrientation pointOrientation = nextOrientation; nextOrientation = nextPlus1Orientation; nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[WrapArrayIndex(i + 2, this.points.Length)].Point - end); // should this point cause the last matched point to be excluded bool removeLastIntersection = nextOrientation == PointOrientation.Colinear && pointOrientation == PointOrientation.Colinear && nextPlus1Orientation != prevOrientation && (this.closedPath || i > 0) && (IsOnSegment(target, edge.Start) || IsOnSegment(target, edge.End)); // is there any chance the segments will intersection (do their bounding boxes touch) bool doIntersect = false; if (pointOrientation == PointOrientation.Colinear || pointOrientation != nextOrientation) { doIntersect = (edge.Min.X - Epsilon) <= target.Max.X && (edge.Max.X + Epsilon) >= target.Min.X && (edge.Min.Y - Epsilon) <= target.Max.Y && (edge.Max.Y + Epsilon) >= target.Min.Y; } precaclulateSpan[i] = new PassPointData { RemoveLastIntersectionAndSkip = removeLastIntersection, RelativeOrientation = pointOrientation, DoIntersect = doIntersect }; prevOrientation = pointOrientation; } // seed the last point for deduping at begining of closed line if (this.closedPath) { int prev = polyCorners - 1; if (precaclulateSpan[prev].DoIntersect) { lastPoint = FindIntersection(this.points[prev].Segment, target); } } for (int i = 0; i < polyCorners && count > 0; i++) { int next = WrapArrayIndex(i + 1, this.points.Length); if (precaclulateSpan[i].RemoveLastIntersectionAndSkip) { if (position > 0) { position--; count++; } continue; } if (precaclulateSpan[i].DoIntersect) { Vector2 point = FindIntersection(this.points[i].Segment, target); if (point != MaxVector) { if (lastPoint.Equivalent(point, Epsilon2)) { lastPoint = MaxVector; int last = WrapArrayIndex(i - 1 + polyCorners, polyCorners); // hit the same point a second time do we need to remove the old one if just clipping if (this.points[next].Point.Equivalent(point, Epsilon)) { next = i; } if (this.points[last].Point.Equivalent(point, Epsilon)) { last = i; } PointOrientation side = precaclulateSpan[next].RelativeOrientation; PointOrientation side2 = precaclulateSpan[last].RelativeOrientation; if (side != side2) { // differnet side we skip adding as we are passing through it continue; } } // only need to track this during odd non zero rulings orientationsSpan[position] = precaclulateSpan[i].RelativeOrientation; buffer[position] = point; position++; count--; } lastPoint = point; } else { lastPoint = MaxVector; } } Vector2 startVector = start; Span <float> distances = stackalloc float[position]; for (int i = 0; i < position; i++) { distances[i] = Vector2.DistanceSquared(startVector, buffer[i]); } var activeBuffer = buffer.Slice(0, position); var activeOrientationsSpan = orientationsSpan.Slice(0, position); SortUtility.Sort(distances, activeBuffer, activeOrientationsSpan); return(position); }