Exemplo n.º 1
0
        public void ErasedLastEntrada()
        {
            if (Entradas.Count <= 0)
            {
                return;
            }

            if (Entradas.Peek() is Numero)
            {
                Numero num = Entradas.Peek() as Numero;

                if (num.IsZero)
                {
                    Entradas.Dequeue();
                }
                else
                {
                    num.UndoLastValueAdded();
                }
            }
            else
            {
                Entradas.Dequeue();
            }

            UpdateTypesPermitidos(Entradas.Peek());
            UpdatedCalculator();
        }
Exemplo n.º 2
0
        public void Calcular()
        {
            Queue <Entrada>   finalExpresion = new Queue <Entrada>();
            Stack <Operacion> stack          = new Stack <Operacion>();

            List <Queue <Entrada> >   tempExpresion        = new List <Queue <Entrada> >();
            List <Stack <Operacion> > tempOperacionesStack = new List <Stack <Operacion> >();

            tempExpresion.Add(new Queue <Entrada>());
            tempOperacionesStack.Add(new Stack <Operacion>());

            int isTemp = 0;

            while (Entradas.Count > 0)
            {
                if (isTemp <= 0)
                {
                    if (Entradas.Peek() is Delimitador)
                    {
                        Delimitador del = Entradas.Dequeue() as Delimitador;
                        if (del.Apertura)
                        {
                            isTemp++;
                            Console.WriteLine($"tem++ {isTemp}");
                            //Esto fue un arreglo rapido por que no lograba procesar bien las expresiones con muchos (()) , habria que implementar un
                            //Object pool para estas filas y stacks temporales
                            tempOperacionesStack.Add(new Stack <Operacion>());
                            tempExpresion.Add(new Queue <Entrada>());

                            tempExpresion[isTemp]        = new Queue <Entrada>();
                            tempOperacionesStack[isTemp] = new Stack <Operacion>();
                            continue;
                        }
                    }
                    else if (Entradas.Peek() is Numero)
                    {
                        finalExpresion.Enqueue(Entradas.Dequeue());
                        continue;
                    }

                    else if (Entradas.Peek() is Operacion)
                    {
                        Operacion operacion = Entradas.Dequeue() as Operacion;
                        if (stack.Count <= 0)
                        {
                            stack.Push(operacion);
                            continue;
                        }

                        bool operacionInsertada = false;

                        while (!operacionInsertada)
                        {
                            if (stack.Count <= 0)
                            {
                                stack.Push(operacion);
                                operacionInsertada = true;
                                continue;
                            }

                            if (stack.Peek().Orden < operacion.Orden)
                            {
                                stack.Push(operacion);
                                operacionInsertada = true;
                                continue;
                            }

                            if (stack.Peek().Orden >= operacion.Orden)
                            {
                                finalExpresion.Enqueue(stack.Pop());
                            }
                        }
                    }
                }
                else
                {
                    if (Entradas.Peek() is Delimitador)
                    {
                        Delimitador del = Entradas.Dequeue() as Delimitador;
                        if (del.Apertura)
                        {
                            isTemp++;

                            tempOperacionesStack.Add(new Stack <Operacion>());
                            tempExpresion.Add(new Queue <Entrada>());

                            tempExpresion[isTemp]        = new Queue <Entrada>();
                            tempOperacionesStack[isTemp] = new Stack <Operacion>();
                            Console.WriteLine($"tem++ {isTemp}");
                            var y = tempOperacionesStack[isTemp].Count;
                            for (int i = 0; i < y; i++)
                            {
                                tempExpresion[isTemp].Enqueue(tempOperacionesStack[isTemp].Pop());
                            }
                            Numero num = CalcularExpresionPostFix(tempExpresion[isTemp]);
                            tempExpresion[isTemp].Enqueue(num);
                            continue;
                        }
                        else
                        {
                            Console.WriteLine($"isTemp-- {isTemp}");
                            var x = tempOperacionesStack[isTemp].Count;
                            for (int i = 0; i < x; i++)
                            {
                                tempExpresion[isTemp].Enqueue(tempOperacionesStack[isTemp].Pop());
                            }
                            tempExpresion[isTemp].Enqueue(CalcularExpresionPostFix(tempExpresion[isTemp]));

                            isTemp--;
                            if (isTemp <= 0)
                            {
                                while (tempExpresion[isTemp + 1].Count > 0)
                                {
                                    finalExpresion.Enqueue(tempExpresion[isTemp + 1].Dequeue());
                                }
                            }
                            else
                            {
                                while (tempExpresion[isTemp + 1].Count > 0)
                                {
                                    tempExpresion[isTemp].Enqueue(tempExpresion[isTemp + 1].Dequeue());
                                }
                            }
                            //aqui temp va al definitivo?
                            continue;
                        }
                    }
                    else if (Entradas.Peek() is Numero)
                    {
                        tempExpresion[isTemp].Enqueue(Entradas.Dequeue());
                        continue;
                    }

                    else if (Entradas.Peek() is Operacion)
                    {
                        Operacion operacion = Entradas.Dequeue() as Operacion;
                        if (tempOperacionesStack[isTemp].Count <= 0)
                        {
                            tempOperacionesStack[isTemp].Push(operacion);
                            continue;
                        }

                        bool operacionInsertada = false;

                        while (!operacionInsertada)
                        {
                            if (tempOperacionesStack[isTemp].Count <= 0)
                            {
                                tempOperacionesStack[isTemp].Push(operacion);
                                operacionInsertada = true;
                                continue;
                            }

                            if (tempOperacionesStack[isTemp].Peek().Orden < operacion.Orden)
                            {
                                tempOperacionesStack[isTemp].Push(operacion);
                                operacionInsertada = true;
                                continue;
                            }

                            if (tempOperacionesStack[isTemp].Peek().Orden >= operacion.Orden)
                            {
                                tempExpresion[isTemp].Enqueue(stack.Pop());
                            }
                        }
                    }
                }
            }

            int m = stack.Count;

            for (int i = 0; i < m; i++)
            {
                finalExpresion.Enqueue(stack.Pop());
            }

            #region testExpresion
            Queue <Entrada> textFila = new Queue <Entrada>();
            Entrada         entrada;
            string          messegeText = "";
            while (finalExpresion.Count > 0)
            {
                entrada      = finalExpresion.Dequeue();
                messegeText += entrada.Symbol();
                textFila.Enqueue(entrada);
            }
            ;

            Console.WriteLine(messegeText);
            while (textFila.Count > 0)
            {
                entrada = textFila.Dequeue();
                finalExpresion.Enqueue(entrada);
            }
            ;
            #endregion

            CurrentValor = CalcularExpresionPostFix(finalExpresion);
            Console.WriteLine("Valor calculado: " + CurrentValor.Valor.ToString());
            UpdatedCalculator();
        }