MAAAAAAATH

MathEngine.cs

using System;
using System.Numerics;

namespace MathEngine
{
    interface IEngine
    {
        string EngineName { get; }
        string[] EngineInputs { get; }
        void RunEngine(string[] inputs);
    }

    static class Tools
    {
        public static BigInteger Factorial(BigInteger n) => Factorial(n, BigInteger.One);

        public static BigInteger Factorial(BigInteger n, BigInteger d)
        {
            var result = BigInteger.One;

            for (var i = n; i > d; --i)
                result *= i;

            return result;
        }

        public static BigInteger Choose(BigInteger n, BigInteger k)
        {
            return Factorial(n, n - k) / Factorial(k);
        }
    }

    class CombinationEngine : IEngine
    {
        public string EngineName => "n choose k";

        public string[] EngineInputs => new string[] {"n", "k"};

        public void RunEngine(string[] inputs)
        {
            var n = BigInteger.Parse(inputs[0]);
            var k = BigInteger.Parse(inputs[1]);

            var result = Tools.Choose(n, k);

            Console.WriteLine($"n({n}) choose k({k}) = {result}");
        }
    }

    class MultiCombinationEngine : IEngine
    {
        public string EngineName => "n multichoose k";

        public string[] EngineInputs => new string[] {"n", "k"};

        public void RunEngine(string[] inputs)
        {
            var n = BigInteger.Parse(inputs[0]);
            var k = BigInteger.Parse(inputs[1]);

            var result = Tools.Choose(n + k - 1, k);

            Console.WriteLine($"n({n}) multichoose k({k}) = {result}");
        }
    }

    class PermutationEngine : IEngine
    {
        public string EngineName => "k-permutations of n";

        public string[] EngineInputs => new string[] {"n", "k"};

        public void RunEngine(string[] inputs)
        {
            var n = BigInteger.Parse(inputs[0]);
            var k = BigInteger.Parse(inputs[1]);

            var result = Tools.Factorial(n, n - k);

            Console.WriteLine($"k({k})-permutations of n({n}) = {result}");
        }
    }

    class MultiPermutationEngine : IEngine
    {
        public string EngineName => "k-permutations of n with repetition";

        public string[] EngineInputs => new string[] {"n", "k"};

        public void RunEngine(string[] inputs)
        {
            var n = BigInteger.Parse(inputs[0]);
            var k = BigInteger.Parse(inputs[1]);

            var result = BigInteger.One;

            for (var i = BigInteger.Zero; i < k; ++i)
                result *= n;

            Console.WriteLine($"k({k})-permutations of n({n}) with repetition = {result}");
        }
    }

    class QuadraticFormula : IEngine
    {
        public string EngineName => "Quadratic formula";

        public string[] EngineInputs => new string[] {"a", "b", "c"};

        public void RunEngine(string[] inputs)
        {
            var a = double.Parse(inputs[0]);
            var b = double.Parse(inputs[1]);
            var c = double.Parse(inputs[2]);

            var aa = checked(a + a);
            var left = checked(-b / aa);
            var right = checked(Math.Sqrt(checked(b * b - 4 * a * c)) / aa);

            Console.WriteLine($"{left} ± {right}");
            Console.WriteLine(left + right);
            Console.WriteLine(left - right);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var engines = new IEngine[]
            {
                new CombinationEngine(),
                new MultiCombinationEngine(),
                new PermutationEngine(),
                new MultiPermutationEngine(),
                new QuadraticFormula()
            };

            bool running = true;
            Console.Title = "Math Engine";
            const string Divider = "--- --- --- --- --- ---";

            while (running)
            {
                Console.WriteLine(Divider);
                Console.WriteLine("Choose Math Engine:");
                Console.WriteLine();
                for (int i = 0; i < engines.Length; ++i)
                {
                    string name = engines[i].EngineName;
                    Console.WriteLine($"[{i}] {name}");
                }
                Console.WriteLine(Divider);

                if (int.TryParse(Console.ReadLine(), out int index) && 0 <= index && index < engines.Length)
                {
                    var engine = engines[index];
                    var inputs = engine.EngineInputs;
                    var arguments = new string[inputs.Length];

                    for (int i = 0; i < arguments.Length; ++i)
                    {
                        var input = inputs[i];
                        Console.WriteLine($"Enter value for '{input}': ");
                        arguments[i] = Console.ReadLine();
                    }

                    try
                    {
                        engine.RunEngine(arguments);
                    }
                    catch (Exception ex)
                    {
                        for (var e = ex; e != null; e = e.InnerException)
                        {
                            Console.WriteLine(e.GetType());
                            Console.WriteLine(e.Message);
                            Console.WriteLine(e.StackTrace);
                        }
                    }
                }
                else
                {
                    running = false;
                }
            }
        }
    }
}