Example #1
0
        public override void DrawState(StateAutomaton stateAutomaton)
        {
            this.ClearOldComments();

            switch (stateAutomaton.StateId)
            {
                case (int) AutomatonBubbleSort.States.Condition:
                {
                    this.DrawCompare(stateAutomaton);
                    
                    break;
                }
                case (int) AutomatonBubbleSort.States.SwappingAdjacentElements:
                {
                    this.DrawSwap(stateAutomaton);
                    
                    break;
                }
                case (int)AutomatonBubbleSort.States.FinalState:
                {
                    selfTimer.Stop();
                    break;
                }
                default:
                {
                    this.visualizationArray.DrawArray(stateAutomaton, graphics);

                    break;
                }
            }
            
           base.DrawComment(stateAutomaton.Comment);
        }
Example #2
0
 private void DrawCompare(StateAutomaton state)
 {
     this.visualizationArray.DrawArray(state, this.graphics);
     
     this.DrawCursor(state.SelectedElements[0]);
     this.DrawSymbolComparison(state.SelectedElements[0]);
 }
        public override void DrawState(StateAutomaton stateAutomaton)
        {
            this.ClearOldComments();


            switch (stateAutomaton.StateId)
            {
                case (int) AutomatonSelectionSort.States.Condition:
                {
                    this.DrawCompare(stateAutomaton);
                    
                    break;
                }
                case (int) AutomatonSelectionSort.States.SwappingElements:
                {
                    this.DrawSwap(stateAutomaton);

                    break;
                }
                case (int) AutomatonSelectionSort.States.InitializeIndexMinimum:
                {
                    this.DrawMin(stateAutomaton);
                    
                    break;
                }
                case (int)AutomatonSelectionSort.States.UpdateMinimum:
                {
                    this.DrawMin(stateAutomaton);

                    break;
                }
                case (int)AutomatonSelectionSort.States.FinalState:
                {
                    this.visualizationArray.DrawArray(stateAutomaton, this.graphics);
                    base.DoPause(null, new EventArgs());
                    break;
                }
                default:
                {
                    this.visualizationArray.DrawArray(stateAutomaton, this.graphics);

                    break;
                }
            }
            
            this.DrawComment(stateAutomaton.Comment);
        }
Example #4
0
        public void DrawArray(StateAutomaton state, Graphics graphics)
        {
            arrayLength = state.Array.Length;
            IdentifyCoordinates();
            SelectElements(state.SelectedElements.ToArray());

            for (var i = 0; i < arrayLength; ++i)
            {
                    var rectangle = new Rectangle(GetCoordinates(i), ElementSize);

                    graphics.FillRectangle(new SolidBrush(GetColorElement(i, state.BoundariesSortedPart)), rectangle);
                    graphics.DrawRectangle(elementsPen, rectangle);
                    graphics.DrawString(state.Array[i].ToString(), digitsFont, digitsBrush,
                    GetCoordinates(i), formatDrawing);
            }

        }
Example #5
0
        public virtual StateAutomaton DoStepBackward()
        {
            if (StepsCount - 1 == 0 || StepsCount == 0)
            {
                return new StateAutomaton(array);
            }

            var newStepsCount = StepsCount-1;
            StepsCount = 0;
            var state = new StateAutomaton(array);

            while (StepsCount != newStepsCount)
            {
                state = DoStepForward();
            }

            return state;
        
        }
 private void DrawCompare(StateAutomaton state)
 {
     this.DrawMin(state);
     
     this.visualizationArray.DrawArray(state, this.graphics);
 }
        public override StateAutomaton DoStepForward()
        {
            var isInterestingState = false;
            StepsCount++;

            var state = new StateAutomaton(array);

            while (!isInterestingState)
            {
                switch (dataModel.State)
                {
                    case States.InitialState:
                    {
                        dataModel.BorderSortedPart = -1;
                        dataModel.State = States.StartOuterLoop;
                       
                        break;
                    }
                    case States.StartOuterLoop:
                        {
                            dataModel.OuterCounter = 0;
                            dataModel.State = States.OuterLoop;
                            
                            break;
                        }
                    case States.OuterLoop:
                    {
                        dataModel.State = dataModel.OuterCounter < dataModel.ArraySize - 1 ? States.InitializeIndexMinimum : States.FinalState;

                        break;
                    }
                    case States.InitializeIndexMinimum:
                    {
                        isInterestingState = true;
                        
                        dataModel.IndexMinimum = dataModel.OuterCounter;
                        
                        state = GetStateSelectionSortAutomaton(dataModel.State);
                        
                        dataModel.State = States.StartInnerLoop;
                            
                        break;
                    }
                    case States.StartInnerLoop:
                    {
                        dataModel.InnerCounter = dataModel.OuterCounter + 1;
                            
                        dataModel.State = States.InnerLoop;
                           
                        break;
                    }
                    case States.InnerLoop:
                    {
                        dataModel.State = dataModel.InnerCounter < dataModel.ArraySize ? States.Condition : States.SwappingElements;
                        
                        break;
                    }
                    case States.Condition:
                    {
                        isInterestingState = true;
                        
                        state = GetStateSelectionSortAutomaton(dataModel.State);
                        
                        dataModel.State = dataModel.Array[dataModel.InnerCounter] < dataModel.Array[dataModel.IndexMinimum] ? 
                            States.UpdateMinimum : States.EndingConditions;

                        break;
                    }
                    case States.UpdateMinimum:
                    {
                        isInterestingState = true;
                        
                        dataModel.IndexMinimum = dataModel.InnerCounter;
                       
                        state = GetStateSelectionSortAutomaton(dataModel.State);
                        
                        dataModel.State = States.EndingConditions;
                         
                        break;
                    }
                    case States.EndingConditions:
                    {
                        dataModel.State = States.IncrementInnerCounter;
                            
                        break;
                    }
                    case States.IncrementInnerCounter:
                    {
                        dataModel.InnerCounter++;
                        dataModel.State = States.InnerLoop;
                        
                        break;
                    }
                    case States.SwappingElements:
                    {
                        dataModel.SwapElements();
                        state = GetStateSelectionSortAutomaton(dataModel.State);
                        isInterestingState = true;
                           
                        dataModel.State = States.IncrementOuterCounter;
                            
                        break;
                    }
                    case States.IncrementOuterCounter:
                    {
                        dataModel.OuterCounter++;
                        dataModel.State = States.OuterLoop;
                            
                        break;
                    }
                    case States.FinalState:
                    {
                        isInterestingState = true;
                        dataModel.BorderSortedPart = dataModel.ArraySize - 1;

                        state = GetStateSelectionSortAutomaton(dataModel.State);
                        
                        break;
                    }
                }
            }

            return state;
        }
Example #8
0
        public override void DrawState(StateAutomaton stateAutomaton)
        {
            switch (stateAutomaton.StateId)
            {
                case (int)AutomatonSiftDown.States.ConditionOnUpdateMaximumChild:
                {
                    DrawCompare(stateAutomaton);
                    break;
                }
                case (int)AutomatonSiftDown.States.ConditionOnUpdateParent:
                {
                    DrawCompare(stateAutomaton);
                    break;
                }
                case (int)AutomatonSiftDown.States.SwappingParentWithMaximumChild:
                {
                    DrawSwap(stateAutomaton);
                    break;
                }
                case (int)AutomatonSiftDown.States.Loop:
                {
                    DrawShifting(stateAutomaton);
                    break;
                }
                case (int)AutomatonHeapSort.States.SwappingElements:
                {
                    DrawSwap(stateAutomaton);
                    break;
                }
                case (int)AutomatonSiftDown.States.EndingConditionOnUpdateMaximumChild:
                {
                    DrawShifting(stateAutomaton);
                    break;
                }
                case (int)AutomatonSiftDown.States.EndLoop:
                {
                    visualizationArray.DrawArray(stateAutomaton, graphics);
                    visualizationHeap.DrawHeap(stateAutomaton, graphics);
                    
                    break;
                }
                case (int)AutomatonHeapSort.States.FinalState:
                {
                    visualizationArray.DrawArray(stateAutomaton, graphics);
                    visualizationHeap.DrawHeap(stateAutomaton, graphics);
                    selfTimer.Stop();
                    
                    break;
                }
                case (int)AutomatonHeapSort.States.InitialState:
                {
                    this.visualizationArray.DrawArray(stateAutomaton, graphics);
                    this.visualizationHeap.DrawHeap(stateAutomaton, graphics);
                    break;
                }
                
                default:
                {
                    this.visualizationArray.DrawArray(stateAutomaton, graphics);
                    this.visualizationHeap.DrawHeap(stateAutomaton, graphics);
                    break;
                }
                
            }

            base.DrawComment(stateAutomaton.Comment);
        }
Example #9
0
 public void DrawCompare(StateAutomaton stateAutomaton)
 {
     visualizationArray.DrawArray(stateAutomaton, graphics);
     visualizationHeap.DrawHeap(stateAutomaton, graphics);
 }
Example #10
0
        public override void DrawSwap(StateAutomaton stateAutomaton)
        {
            base.DrawSwap(stateAutomaton);

            visualizationHeap.DrawHeap(stateAutomaton, graphics);
        }
Example #11
0
 public virtual void DrawState(StateAutomaton stateAutomaton)
 {
    
 }
Example #12
0
 public virtual void DrawSwap(StateAutomaton state)
 {
     visualizationArray.DrawArray(state, graphics);
 }
 private void DrawMin(StateAutomaton state)
 {
     this.visualizationArray.DrawArray(state, this.graphics);
     
     graphics.DrawString(String.Format("Текущий минимум  = {0}", state.Minimum), digitsFont, digitsBrush, 80 + 100 * 4, 40, formatDrawing);
 }
Example #14
0
        private void DrawDetachedNode(int index, StateAutomaton state, Graphics graphics)
        {
            if (index != 0)
            {
                DrawEdge(index, false, graphics);
                var parent = GetParent(index);
                DrawNode(parent, state, graphics);
            }

            else
            {
                DrawRoot(state, graphics);
            }
        }
Example #15
0
        private void DrawNode(int index, StateAutomaton state,  Graphics graphics)
        {
            if (state.BorderSortedPart >= 0 && index >= state.BorderSortedPart)
                DrawDetachedNode(index, state, graphics);
            else
                DrawEdge(index, true, graphics);

            
            graphics.FillEllipse(new SolidBrush(GetColorElement(index, state.BorderSortedPart)), GetCoordinatesNode(index));
            graphics.DrawEllipse(elementsPen, GetCoordinatesNode(index));

            graphics.DrawString(state.Array[index].ToString(), nodesFontDigits, digitsBrush, GetCoordinatesValue(index),
                    formatDrawing);
        }
Example #16
0
        public void DrawHeap(StateAutomaton state, Graphics graphics)
        {
            arrayLength = state.Array.Length;
            DefineCoordinates();

            SelectNodes(state.SelectedElements.ToArray());
            SelectNode(state.SiftingElement);
            DrawRoot(state, graphics);
            for (var i = 0; i <= arrayLength / 2 - 1; ++i)
            {
                
                
                if (i * 2 + 1 < arrayLength)
                    DrawNode(i * 2 + 1, state, graphics);
                
                if (i * 2 + 2 < arrayLength)
                    DrawNode(i * 2 + 2, state, graphics);
            }
        }
Example #17
0
        public void DrawRoot(StateAutomaton state, Graphics graphics)
        {
            graphics.FillEllipse(new SolidBrush(GetColorElement(0, state.BorderSortedPart)), GetCoordinatesNode(0));
            graphics.DrawEllipse(elementsPen, GetCoordinatesNode(0));
            graphics.DrawString(state.Array[0].ToString(), nodesFontDigits, digitsBrush, GetCoordinatesValue(0),
                   formatDrawing);

        }