calculator.cs

function recognition



using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<String> expressions = new List<String>();
            while (true)
            {
                Console.WriteLine("Menú:\n1.- Escriba nueva expresión.\n2.- Busque una expresión ya escrita.\n3.- Salir.");
                Console.Write("Decisión: ");
                int decision = 0;
                try
                {
                    decision = int.Parse(Console.ReadLine());
                }
                catch (Exception exc)
                {
                    break;
                }
                if (decision == 1)
                {
                    Console.Write("Escriba la expresión: ");
                    String expr = Console.ReadLine();
                    expr = expr.Replace(" ", "");
                    int process = 0;
                    while (true)
                    {
                        try
                        {
                            Console.Write("Escoja el número de procesadores: ");
                            process = int.Parse(Console.ReadLine());
                            while (process < -1 || process > 8)
                            {
                                Console.Write("Escoja el número de procesadores: ");
                                process = int.Parse(Console.ReadLine());
                            }
                            break;
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Formato inválido");
                            continue;
                        }
                    }
                    if (Validate(expr))
                    {
                        expressions.Add(expr);
                        Resolve(expr, process);
                        Console.WriteLine();
                    }
                    else
                    {
                        Console.WriteLine("La expresión es incorrecta\n");
                        continue;
                    }
                }
                else if (decision == 2)
                {
                    if (expressions.Count == 0)
                        Console.WriteLine("No existen expresiones\n");
                    else
                    {
                        Console.WriteLine("Escoja la expresión que desea evaluar, escriba 0 para regresar al menú:");
                        int subdecision = 1, process = 0;
                        String exprChosen = "";
                        while (true)
                        {
                            int i = 1;
                            foreach (String expr in expressions)
                                Console.WriteLine("{0}: {1}", i++, expr);

                            while (true)
                            {
                                try
                                {
                                    Console.Write("Escoja el número de la expresión: ");
                                    exprChosen = expressions[(int.Parse(Console.ReadLine())) - 1];
                                    break;
                                }
                                catch (Exception e)
                                {
                                    Console.WriteLine("La decisión no es válida");
                                    continue;
                                }
                            }

                            try
                            {
                                Console.Write("Escoja el número de procesadores: ");
                                process = int.Parse(Console.ReadLine());
                                while (process < -1 || process > 8)
                                {
                                    Console.Write("Escoja el número de procesadores: ");
                                    process = int.Parse(Console.ReadLine());
                                }
                                break;
                            }
                            catch (Exception exc)
                            {
                                Console.WriteLine("Opción no válida");
                                continue;
                            }
                        }
                        if (subdecision != 0)
                            Resolve(exprChosen, process);
                        else
                            continue;
                    }
                }
                else
                    break;
            }
        }

        /// <summary>
        /// Valida una expresión matemática
        /// </summary>
        /// <param name="expr">La expresión a evaluar</param>
        /// <returns>Verdadero si es válida la expresión, Falso de otro modo</returns>
        static bool Validate(String expr)
        {
            if (expr.Length == 0)
                return false;

            if (expr.Contains("R"))
                return false;

            Stack<char> parenthesis = new Stack<char>();
            for (int i = 0; i < expr.Length; i++)
            {
                if (expr[i] == '(')
                    parenthesis.Push('(');
                else if (expr[i] == ')')
                {
                    try
                    {
                        parenthesis.Pop();
                    }
                    catch (InvalidOperationException ioe)
                    {
                        return false;
                    }

                    if (i != (expr.Length - 1) && expr[i + 1] == '(')
                        return false;

                    if (i != 0 && expr[i - 1] == '(')
                        return false;
                }
                else if (expr[i] == '*' || expr[i] == '/' || expr[i] == '%')
                {
                    if (i == 0 || i == expr.Length - 1)
                        return false;
                    else if (expr[i + 1] == '+' || expr[i + 1] == '-')
                    {
                        if (expr.Length < 3)
                            return false;

                        if (IsOperator(expr[i + 2].ToString()) || expr[i + 2] == '+' || expr[i + 2] == '-')
                            return false;
                    }
                    else if (IsOperator(expr[i + 1].ToString()) || IsOperator(expr[i - 1].ToString()) || expr[i - 1] == '+' || expr[i - 1] == '-')
                        return false;
                }
            }

            if (parenthesis.Count == 0)
                return true;

            return false;
        }

        /// <summary>
        /// Organiza las operaciones en la cantidad de procesos elegidos por el usuario
        /// </summary>
        /// <param name="expr">La expresión a evaluar</param>
        /// /// <param name="process">La cantidad de procesos sobre los que correra</param>
        static void Resolve(String expr, int process)
        {
            List<String> postOrder = IntoPost(expr);
            List<R> relations = IdentifyOperations(postOrder);

            String[,] table = Organize(relations, process);

            Console.WriteLine();

            for (int i = 0; i < table.GetLength(1); i++)
                Console.Write("\tTiempo{0}:\t", i + 1);
            Console.WriteLine();

            for (int i = 0; i < table.GetLength(0); i++)
            {
                Console.Write("Proceso{0}:\t", i + 1);
                for (int j = 0; j < table.GetLength(1); j++)
                    Console.Write(table[i, j] + "\t");
                Console.WriteLine();
            }

            Console.WriteLine();
        }

        /// <summary>
        /// Convierte una expresión en notación infija a notación postfija
        /// </summary>
        /// <param name="expr">La expresión a evaluar</param>
        /// <returns>Una lista de los elementos de la expresión en postorden</returns>
        static List<String> IntoPost(String expr)
        {
            List<String> inOrder = new List<String>();

            bool done = false;
            int begin = 0;

            for (int i = 0; i < expr.Length; i++)
            {
                if (!done)
                    begin = i;

                if (expr[i] == '(')
                    inOrder.Add(expr[i].ToString());
                else if (i == (expr.Length - 1) && expr[i] != ')')
                    inOrder.Add(expr.Substring(begin, (i + 1) - begin));
                else if (expr[i] == '*' || expr[i] == '/' || expr[i] == '%' || expr[i] == ')')
                {
                    if (expr[i - 1] != ')')
                        inOrder.Add(expr.Substring(begin, i - begin));
                    inOrder.Add(expr[i].ToString());
                    done = false;
                }
                else if (expr[i] == '+' || expr[i] == '-')
                {
                    if (i == 0 || expr[i - 1] == '(' || expr[i - 1] == '+' || expr[i - 1] == '-' || expr[i - 1] == '*' || expr[i - 1] == '/' || expr[i - 1] == '%')
                    {
                        begin = i;
                        done = true;
                    }
                    else
                    {
                        inOrder.Add(expr.Substring(begin, i - begin));
                        inOrder.Add(expr[i].ToString());
                        done = false;
                    }
                }
                else if (!done)
                {
                    begin = i;
                    done = true;
                }
            }

            inOrder.RemoveAll(RemoveEmpty);

            List<String> postOrder = new List<String>();
            Stack<String> helpStack = new Stack<String>();

            while (inOrder.Count != 0)
            {
                String elem = inOrder[0];
                inOrder.RemoveAt(0);
                if (elem == "(")
                    helpStack.Push(elem);
                else if (elem == ")")
                {
                    while (helpStack.Count != 0 && helpStack.Peek() != "(")
                        postOrder.Add(helpStack.Pop());
                    if (helpStack.Count != 0 && helpStack.Peek() == "(")
                        helpStack.Pop();
                }
                else if (elem == "+" || elem == "-" || elem == "*" || elem == "/" || elem == "%")
                {
                    while (helpStack.Count != 0 && ((!IsOperator(elem) && elem != "+" && elem != "-") || Priority(helpStack.Peek()[0]) >= Priority(elem[0])))
                        postOrder.Add(helpStack.Pop());
                    helpStack.Push(elem);
                }
                else
                    postOrder.Add(elem);
            }

            while (helpStack.Count != 0)
                postOrder.Add(helpStack.Pop());

            return postOrder;