public void Pop(object targetForm, StackMode stackMode) { if (stackMode != StackMode.None) { if (stackMode == StackMode.FirstAvailable) { for (int i = 0; i < this.m_syncList.Count; i++) { if (this.m_syncList[i] == targetForm) { this.m_syncList[i] = null; this.m_iCount--; break; } } } else if ((stackMode == StackMode.Top) && this.m_syncList.Contains(targetForm)) { this.m_syncList.Remove(targetForm); this.m_iCount--; } if (this.m_iCount == 0) { this.m_syncList.Clear(); } } }
/** * Creates an inventory. * * @param capacity The capacity. * @param mode The {@link StackMode}. * @throws IllegalArgumentException If the capacity is negative. * @throws NullPointerException If the mode is {@code null}. */ public Inventory(int capacity, StackMode mode) { Guard.Argument(capacity, nameof(capacity)).GreaterThan(0); this._capacity = capacity; this._mode = mode; _items = new Item[capacity]; }
public object Peek(StackMode stackMode) { if (this.m_syncList.Count > 0) { return this.m_syncList[this.m_syncList.Count - 1]; } return null; }
public static void Stack(IEnumerable <IBaseShape> shapes, StackMode mode, IHistory history) { var boxes = new List <ShapeBox>(); foreach (var shape in shapes) { boxes.Add(new ShapeBox(shape)); } if (boxes.Count < 2) { return; } var bounds = new GroupBox(boxes); switch (mode) { case StackMode.Horizontal: { boxes.Sort(ShapeBox.CompareLeft); double offset = boxes[0].Left + boxes[0].Width; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dx = offset - box.Left; double dy = 0.0; MoveShapeByWithHistory(box.Shape, dx, dy, history); offset += box.Width; } } break; case StackMode.Vertical: { boxes.Sort(ShapeBox.CompareTop); double offset = boxes[0].Top + boxes[0].Height; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dx = 0.0; double dy = offset - box.Top; MoveShapeByWithHistory(box.Shape, dx, dy, history); offset += box.Height; } } break; } }
public static void Stack(IEnumerable <IBaseShape> shapes, StackMode mode, IHistory history) { var groupBox = new GroupBox(shapes.ToList()); if (groupBox.Boxes.Length < 2) { return; } var boxes = groupBox.Boxes.ToList(); switch (mode) { case StackMode.Horizontal: { boxes.Sort(ShapeBox.CompareLeft); double offset = boxes[0].Bounds.Left + boxes[0].Bounds.Width; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dx = offset - box.Bounds.Left; double dy = 0.0; box.MoveByWithHistory(dx, dy, history); offset += box.Bounds.Width; } } break; case StackMode.Vertical: { boxes.Sort(ShapeBox.CompareTop); double offset = boxes[0].Bounds.Top + boxes[0].Bounds.Height; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dx = 0.0; double dy = offset - box.Bounds.Top; box.MoveByWithHistory(dx, dy, history); offset += box.Bounds.Height; } } break; } }
public object Push(object newObject, StackMode stackMode) { bool flag = false; object obj2 = null; if (stackMode == StackMode.None) { return null; } if (stackMode != StackMode.FirstAvailable) { if (stackMode == StackMode.Top) { if (this.m_syncList.Count > 0) { obj2 = this.m_syncList[this.m_syncList.Count - 1]; } this.m_syncList.Add(newObject); } } else { for (int i = 0; i < this.m_syncList.Count; i++) { if (this.m_syncList[i] == null) { this.m_syncList[i] = newObject; flag = true; break; } obj2 = this.m_syncList[i]; } if (!flag) { this.m_syncList.Add(newObject); } } this.m_iCount++; return obj2; }
/// <summary> /// Stacks the points. /// </summary> /// <param name="stackables">The stackables.</param> /// <param name="stackAt">The stack at.</param> /// <param name="stackIndex">Index of the stack.</param> /// <param name="mode">The mode.</param> protected void StackPoints(IEnumerable <ISeriesView> stackables, AxisOrientation stackAt, int stackIndex, StackMode mode = StackMode.Values) { var groupedStackables = stackables.GroupBy(s => s is IGroupedStackedSeriesView ? (s as IGroupedStackedSeriesView).Grouping : 0).ToList(); foreach (var groupedStack in groupedStackables) { var stackedColumns = groupedStack.SelectMany(x => x.ActualValues.GetPoints(x)) .GroupBy(x => stackAt == AxisOrientation.X ? x.Y : x.X); double mostLeft = 0, mostRight = 0; foreach (var column in stackedColumns) { double sumLeft = 0, sumRight = 0; foreach (var item in column) { var s = stackAt == AxisOrientation.X ? item.X : item.Y; if (s < 0) { sumLeft += s; } else { sumRight += s; } } var lastLeft = 0d; var lastRight = 0d; var leftPart = 0d; var rightPart = 0d; foreach (var point in column) { var pulled = stackAt == AxisOrientation.X ? point.X : point.Y; //notice using (pulled < 0) or (pulled <= 0) could cause an issue similar to //https://github.com/beto-rodriguez/Live-Charts/issues/231 //from that issue I changed <= to < //only because it is more common to use positive values than negative //you could face a similar issue if you are stacking only negative values //a work around is forcing (pulled < 0) to be true, //instead of using zero values, use -0.000000001/ if (pulled < 0) { point.From = lastLeft; point.To = lastLeft + pulled; point.Sum = sumLeft; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; leftPart += point.Participation; point.StackedParticipation = leftPart; lastLeft = point.To; } else { point.From = lastRight; point.To = lastRight + pulled; point.Sum = sumRight; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; rightPart += point.Participation; point.StackedParticipation = rightPart; lastRight = point.To; } } if (sumLeft < mostLeft) { mostLeft = sumLeft; } if (sumRight > mostRight) { mostRight = sumRight; } } if (stackAt == AxisOrientation.X) { var ax = AxisX[stackIndex]; if (mode == StackMode.Percentage) { if (double.IsNaN(ax.MinValue)) { ax.BotLimit = 0; } if (double.IsNaN(ax.MaxValue)) { ax.TopLimit = 1; } } else { if (mostLeft < ax.BotLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator if (double.IsNaN(ax.MinValue)) { ax.BotLimit = mostLeft == 0.0 ? 0.0 : Math.Floor(mostLeft / ax.S) * ax.S; } } if (mostRight > ax.TopLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator if (double.IsNaN(ax.MaxValue)) { ax.TopLimit = mostRight == 0.0 ? 0.0 : (Math.Floor(mostRight / ax.S) + 1.0) * ax.S; } } } } if (stackAt == AxisOrientation.Y) { var ay = AxisY[stackIndex]; if (mode == StackMode.Percentage) { if (double.IsNaN(ay.MinValue)) { ay.BotLimit = 0; } if (double.IsNaN(ay.MaxValue)) { ay.TopLimit = 1; } } else { if (mostLeft < ay.BotLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator if (double.IsNaN(ay.MinValue)) { ay.BotLimit = mostLeft == 0.0 ? 0.0 : Math.Floor(mostLeft / ay.S) * ay.S; } } if (mostRight > ay.TopLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator if (double.IsNaN(ay.MaxValue)) { ay.TopLimit = mostRight == 0.0 ? 0.0 : (Math.Floor(mostRight / ay.S) + 1.0) * ay.S; } } } } } }
/// <summary>Opens a widget.</summary> public Widget open(string typeName, string url, WidgetDelegate preload, Dictionary <string, object> globals) { if (Manager.widgetTypes == null) { // Load the widgets now! Modular.AssemblyScanner.FindAllSubTypesNow(typeof(Widgets.Widget), delegate(Type t){ // Add it as an available widget: Manager.Add(t); } ); } Type type; if (!Manager.widgetTypes.TryGetValue(typeName, out type)) { UnityEngine.Debug.Log("Warning: Requested to open a widget called '" + typeName + "' but it doesn't exist."); if (preload != null) { // Invoke the load method: preload(null); } return(null); } // Get existing: Widget same = get(typeName, null); // Get stacking behaviour: StackMode stacking = StackMode.Close; if (same != null) { stacking = same.StackMode; } object stackModeObj; if (globals != null && globals.TryGetValue("-spark-stack-mode", out stackModeObj)) { string stackMode = stackModeObj.ToString().Trim().ToLower(); if (stackMode == "hide") { stacking = StackMode.Hide; } else if (stackMode == "close") { stacking = StackMode.Close; } else if (stackMode == "hijack") { stacking = StackMode.Hijack; } else { stacking = StackMode.Over; } } if (stacking == StackMode.Hijack) { // Hijack an existing widget! Just load straight into it but clear its event handlers: same.RunLoad = true; same.ClearEvents(); if (preload != null) { preload(same); } same.Load(url, globals); same.TryLoadEvent(globals); return(same); } // instance it now: Widget w = Activator.CreateInstance(type) as Widget; if (w == null) { return(null); } if (stacking == StackMode.Hide) { // Hides any widget of the same type. if (same != null) { // Make sure it's actually the visible one: same = same.GetVisibleWidget(); same.Visibility(false, w); w.HidWidget = same; } } else if (stacking == StackMode.Close && same != null) { // Close all widgets of the same type. // For each one.. for (int i = Widgets.Count - 1; i >= 0; i--) { same = Widgets[i]; // Match? if (same.Type == typeName) { same.close(); } } } // Apply type: w.Type = typeName; if (preload != null) { preload(w); } // Add now: SetupWidget(w, url, globals); return(w); }
public static void Stack(IToolContext context, StackMode mode) { if (context.DocumentContainer?.ContainerView?.SelectionState != null) { var shapes = new List <IBaseShape>(context.DocumentContainer.ContainerView.SelectionState?.Shapes); var boxes = new List <Box>(); foreach (var shape in shapes) { if (!(shape is IPointShape)) { boxes.Add(new Box(shape)); } } if (boxes.Count >= 2) { context.DocumentContainer?.ContainerView?.SelectionState?.Dehover(); context.DocumentContainer?.ContainerView?.SelectionState?.Clear(); var bounds = new Bounds(boxes); switch (mode) { case StackMode.Horizontal: { boxes.Sort(Box.CompareHorizontalLeft); boxes[0].shape.Select(context.DocumentContainer.ContainerView.SelectionState); double offset = boxes[0].ax + boxes[0].w; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dx = offset - box.ax; box.shape.Move(context.DocumentContainer.ContainerView.SelectionState, dx, 0.0); box.shape.Select(context.DocumentContainer.ContainerView.SelectionState); offset += box.w; } } break; case StackMode.Vertical: { boxes.Sort(Box.CompareVerticalTop); boxes[0].shape.Select(context.DocumentContainer.ContainerView.SelectionState); double offset = boxes[0].ay + boxes[0].h; for (int i = 1; i <= boxes.Count - 1; i++) { var box = boxes[i]; double dy = offset - box.ay; box.shape.Move(context.DocumentContainer.ContainerView.SelectionState, 0.0, dy); box.shape.Select(context.DocumentContainer.ContainerView.SelectionState); offset += box.h; } } break; } context.DocumentContainer?.ContainerView?.InputService?.Redraw?.Invoke(); } } }
/// <summary> /// Constructor. /// </summary> /// <param name="mode">Stacking mode.</param> /// <param name="overflow">Overflow handling mode.</param> public StackContent( StackMode mode, OverflowMode overflow ) : base() { Mode = mode; Overflow = overflow; }
/// <summary> /// Constructor. /// </summary> /// <param name="mode">Stacking mode.</param> /// <param name="overflow">Overflow handling mode.</param> public StackContent(StackMode mode, OverflowMode overflow) : base() { Mode = mode; Overflow = overflow; }
protected void StackPoints(IEnumerable <ISeriesView> stackables, AxisOrientation stackAt, int stackIndex, StackMode mode = StackMode.Values) { var stackedColumns = stackables.Select(x => x.ActualValues.GetPoints(x).ToArray()).ToArray(); var maxI = stackedColumns.Select(x => x.Length).DefaultIfEmpty(0).Max(); for (var i = 0; i < maxI; i++) { var cols = stackedColumns .Select(x => x.Length > i ? new StackedSum(Pull(x[i], stackAt)) : new StackedSum()).ToArray(); var sum = new StackedSum { Left = cols.Select(x => x.Left).DefaultIfEmpty(0).Sum(), Right = cols.Select(x => x.Right).DefaultIfEmpty(0).Sum() }; if (stackAt == AxisOrientation.X) { if (mode == StackMode.Percentage) { AxisX[stackIndex].BotLimit = 0; AxisX[stackIndex].TopLimit = 1; } else { if (sum.Left < AxisX[stackIndex].BotLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator AxisX[stackIndex].BotLimit = sum.Left == 0 ? 0 : ((int)(sum.Left / AxisX[stackIndex].S) - 1) * AxisX[stackIndex].S; } if (sum.Right > AxisX[stackIndex].TopLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator AxisX[stackIndex].TopLimit = sum.Right == 0 ? 0 : ((int)(sum.Right / AxisX[stackIndex].S) + 1) * AxisX[stackIndex].S; } } } if (stackAt == AxisOrientation.Y) { if (mode == StackMode.Percentage) { AxisY[stackIndex].BotLimit = 0; AxisY[stackIndex].TopLimit = 1; } else { if (sum.Left < AxisY[stackIndex].BotLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator AxisY[stackIndex].BotLimit = sum.Left == 0 ? 0 : ((int)(sum.Left / AxisY[stackIndex].S) - 1) * AxisY[stackIndex].S; } if (sum.Right > AxisY[stackIndex].TopLimit) { // ReSharper disable once CompareOfFloatsByEqualityOperator AxisY[stackIndex].TopLimit = sum.Right == 0 ? 0 : ((int)(sum.Right / AxisY[stackIndex].S) + 1) * AxisY[stackIndex].S; } } } var lastLeft = 0d; var lastRight = 0d; var leftPart = 0d; var rightPart = 0d; foreach (var col in stackedColumns) { if (i >= col.Length) { continue; } var point = col[i]; var pulled = Pull(point, stackAt); //notice using (pulled < 0) or (pulled <= 0) could cause an issue similar to //https://github.com/beto-rodriguez/Live-Charts/issues/231 //from that issue I changed <= to < //only because it is more common to use positive values than negative //you could face a similar issue if you are stacking only negative values //a work around is forcing (pulled < 0) to be true, //instead of using zero values, use -0.000000001/ if (pulled < 0) { point.From = lastLeft; point.To = lastLeft + pulled; point.Sum = sum.Left; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; leftPart += point.Participation; point.StackedParticipation = leftPart; lastLeft = point.To; } else { point.From = lastRight; point.To = lastRight + pulled; point.Sum = sum.Right; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; rightPart += point.Participation; point.StackedParticipation = rightPart; lastRight = point.To; } } } }
protected void StackPoints(IEnumerable <ISeriesView> stackables, AxisTags stackAt, int stackIndex, StackMode mode = StackMode.Values) { var stackedColumns = stackables.Select(x => x.Values.Points.ToArray()).ToArray(); var maxI = stackedColumns.Select(x => x.Length).DefaultIfEmpty(0).Max(); for (var i = 0; i < maxI; i++) { var cols = stackedColumns .Select(x => x.Length > i ? new StackedSum(Pull(x[i], stackAt)) : new StackedSum()).ToArray(); var sum = new StackedSum { Left = cols.Select(x => x.Left).DefaultIfEmpty(0).Sum(), Right = cols.Select(x => x.Right).DefaultIfEmpty(0).Sum() }; if (stackAt == AxisTags.X) { if (mode == StackMode.Percentage) { AxisX[stackIndex].MinLimit = 0; AxisX[stackIndex].MaxLimit = 1; } else { if (sum.Left < AxisX[stackIndex].MinLimit) { AxisX[stackIndex].MinLimit = sum.Left == 0 ? 0 : ((int)(sum.Left / AxisX[stackIndex].S) - 1) * AxisX[stackIndex].S; } if (sum.Right > AxisX[stackIndex].MaxLimit) { AxisX[stackIndex].MaxLimit = sum.Right == 0 ? 0 : ((int)(sum.Right / AxisX[stackIndex].S) + 1) * AxisX[stackIndex].S; } } } if (stackAt == AxisTags.Y) { if (mode == StackMode.Percentage) { AxisY[stackIndex].MinLimit = 0; AxisY[stackIndex].MaxLimit = 1; } else { if (sum.Left < AxisY[stackIndex].MinLimit) { AxisY[stackIndex].MinLimit = sum.Left == 0 ? 0 : ((int)(sum.Left / AxisY[stackIndex].S) - 1) * AxisY[stackIndex].S; } if (sum.Right > AxisY[stackIndex].MaxLimit) { AxisY[stackIndex].MaxLimit = sum.Right == 0 ? 0 : ((int)(sum.Right / AxisY[stackIndex].S) + 1) * AxisY[stackIndex].S; } } } var lastLeft = 0d; var lastRight = 0d; var leftPart = 0d; var rightPart = 0d; foreach (var col in stackedColumns) { if (i >= col.Length) { continue; } var point = col[i]; var pulled = Pull(point, stackAt); if (pulled <= 0) { point.From = lastLeft; point.To = lastLeft + pulled; point.Sum = sum.Left; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; leftPart += point.Participation; point.StackedParticipation = leftPart; lastLeft = point.To; } else { point.From = lastRight; point.To = lastRight + pulled; point.Sum = sum.Right; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; rightPart += point.Participation; point.StackedParticipation = rightPart; lastRight = point.To; } } } }
public static int[][] Arrangements(int n, int k) { if (n < 1 || k > n) { return(new int[0][]); } List <int[]> results = new List <int[]>(); Stack <int> stack = new Stack <int>(); stack.Push(0); StackMode stackMode = StackMode.GoUp; while (stack.Count > 0) { switch (stackMode) { case StackMode.GoUp: bool canGoUp = stack.Count < k; if (canGoUp) { // incercam sa urcam for (int i = 0; i < n; i++) { bool isValidValue = !stack.Contains(i); if (isValidValue) { // pot urca stack.Push(i); bool isSolution = stack.Count == k; if (isSolution) { int[] solutionArray = stack.ToArray(); Array.Reverse(solutionArray); results.Add(solutionArray); // Console.WriteLine(string.Join(", ", stack)); } // am reusit sa pun o valoare valida pe nivelul curent // si continui sa incerc sa urc in stiva break; } } } else { stackMode = StackMode.IncrementCurrent; } break; case StackMode.IncrementCurrent: int nextValue = stack.Peek() + 1; while (nextValue < n) { bool isValidValue = !stack.Contains(nextValue); if (isValidValue) { stack.Pop(); stack.Push(nextValue); bool isSolution = stack.Count == k; if (isSolution) { int[] solutionArray = stack.ToArray(); Array.Reverse(solutionArray); results.Add(solutionArray); // Console.WriteLine(string.Join(", ", stack)); } else { stackMode = StackMode.GoUp; } break; } nextValue++; } if (nextValue >= n) { stackMode = StackMode.GoDown; } break; case StackMode.GoDown: bool canGoDown = stack.Count > 0; if (canGoDown) { stack.Pop(); stackMode = StackMode.IncrementCurrent; } break; } } return(results.ToArray()); }
/// <summary> /// Stacks the points. /// </summary> /// <param name="stackables">The stackables.</param> /// <param name="stackAt">The stack at.</param> /// <param name="stackIndex">Index of the stack.</param> /// <param name="mode">The mode.</param> protected void StackPoints(IEnumerable<ISeriesView> stackables, AxisOrientation stackAt, int stackIndex, StackMode mode = StackMode.Values) { var stackedColumns = stackables.SelectMany(x => x.ActualValues.GetPoints(x)) .GroupBy(x => stackAt == AxisOrientation.X ? x.Y : x.X); double mostLeft = 0, mostRight = 0; foreach (var column in stackedColumns) { double sumLeft = 0, sumRight = 0; foreach (var item in column) { var s = stackAt == AxisOrientation.X ? item.X : item.Y; if (s < 0) sumLeft += s; else sumRight += s; } var lastLeft = 0d; var lastRight = 0d; var leftPart = 0d; var rightPart = 0d; foreach (var point in column) { var pulled = stackAt == AxisOrientation.X ? point.X : point.Y; //notice using (pulled < 0) or (pulled <= 0) could cause an issue similar to //https://github.com/beto-rodriguez/Live-Charts/issues/231 //from that issue I changed <= to < //only because it is more common to use positive values than negative //you could face a similar issue if you are stacking only negative values //a work around is forcing (pulled < 0) to be true, //instead of using zero values, use -0.000000001/ if (pulled < 0) { point.From = lastLeft; point.To = lastLeft + pulled; point.Sum = sumLeft; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; leftPart += point.Participation; point.StackedParticipation = leftPart; lastLeft = point.To; } else { point.From = lastRight; point.To = lastRight + pulled; point.Sum = sumRight; point.Participation = (point.To - point.From) / point.Sum; point.Participation = double.IsNaN(point.Participation) ? 0 : point.Participation; rightPart += point.Participation; point.StackedParticipation = rightPart; lastRight = point.To; } } if (sumLeft < mostLeft) mostLeft = sumLeft; if (sumRight > mostRight) mostRight = sumRight; } if (stackAt == AxisOrientation.X) { if (mode == StackMode.Percentage) { AxisX[stackIndex].BotLimit = 0; AxisX[stackIndex].TopLimit = 1; } else { if (mostLeft < AxisX[stackIndex].BotLimit) // ReSharper disable once CompareOfFloatsByEqualityOperator AxisX[stackIndex].BotLimit = mostLeft == 0 ? 0 : ((int) (mostLeft/AxisX[stackIndex].S) - 1)*AxisX[stackIndex].S; if (mostRight > AxisX[stackIndex].TopLimit) // ReSharper disable once CompareOfFloatsByEqualityOperator AxisX[stackIndex].TopLimit = mostRight == 0 ? 0 : ((int) (mostRight/AxisX[stackIndex].S) + 1)*AxisX[stackIndex].S; } } if (stackAt == AxisOrientation.Y) { if (mode == StackMode.Percentage) { AxisY[stackIndex].BotLimit = 0; AxisY[stackIndex].TopLimit = 1; } else { if (mostLeft < AxisY[stackIndex].BotLimit) // ReSharper disable once CompareOfFloatsByEqualityOperator AxisY[stackIndex].BotLimit = mostLeft == 0 ? 0 : ((int) (mostLeft/AxisY[stackIndex].S) - 1)*AxisY[stackIndex].S; if (mostRight > AxisY[stackIndex].TopLimit) // ReSharper disable once CompareOfFloatsByEqualityOperator AxisY[stackIndex].TopLimit = mostRight == 0 ? 0 : ((int) (mostRight/AxisY[stackIndex].S) + 1)*AxisY[stackIndex].S; } } }