C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Threading.Tasks;

namespace ConsoleApp4
{
    public class Program
    { 
        public static void Main(string[] args)
        {
            double x0 = 0;
            double xn = 1;
            int  n = 5;

            ///*
            ////////////////////////for one equation
            List<double> y0 = new List<double> { 1.5 };
            List<Function> functions = new List<Function> { new Function("y - x", "x", "y") };
            DifferentialEquation equation = new DifferentialEquation(x0, xn, n, y0, functions, 1.8, 2.12, 2.464);
            //List<Point> result = equation.MethodsEuler();
            //List<Point> result = equation.MethodsRungeKutta();
            List<Point> result = equation.MethodsAdamsa(); 
            //*/

            /*
            ///////////////////////for two equations
            List<double> y02 = new List<double> { 2, 3 };
            List<Function> functions2 = new List<Function> { new Function("2*z-3*y", "x", "y", "z"), new Function("z-2*y", "x", "y", "z") }; DifferentialEquation equation2 = new DifferentialEquation(x0, xn, n, y02, functions2);
            List<List<Point>> result2 = equation2.MethodsEuler2();
            // List<List<Point>> result = equation2.MethodsRungeKutta2(); 
            //*/

        }
        
    }
    public class Function
    {
        public Function(string str, params string[] variables)
        {
            operators = new List<string>(standart_operators);
            operators.AddRange(prefix_operators);
            this.strFunction = str;
            this.variables = new List<string>(variables);
            PostfixNotation = ConvertToPostfixNotation(strFunction);
        }

        public string strFunction;

        private List<string> operators;

        private List<string> standart_operators =
            new List<string>(new string[] { "(", ")", "+", "-", "*", "/", "^" });

        private List<string> prefix_operators =
            new List<string>(new string[] { "cos", "sin", "tg", "ctg", "ln", "log10", "exp" });

        string[] PostfixNotation;

        private List<string> variables;

        private List<string> constants = new List<string>(new string[] { "e", "pi" });
        private List<double> constantValues = new List<double>(new double[] { Math.E, Math.PI });


        private IEnumerable<string> Separate(string input)
        {
            int pos = 0;
            while (pos < input.Length)
            {
                string s = string.Empty + input[pos];
                if (!standart_operators.Contains(input[pos].ToString()))
                {
                    if (Char.IsDigit(input[pos]))
                        for (int i = pos + 1; i < input.Length &&
                            (Char.IsDigit(input[i]) || input[i] == ',' || input[i] == '.'); i++)
                            s += input[i];
                    else if (Char.IsLetter(input[pos]))
                        for (int i = pos + 1; i < input.Length &&
                            (Char.IsLetter(input[i]) || Char.IsDigit(input[i])); i++)
                            s += input[i];
                }
                yield return s;
                pos += s.Length;
            }
        }
        private byte GetPriority(string s)
        {
            switch (s)
            {
                case "(":
                case ")":
                    return 0;
                case "+":
                case "-":
                    return 1;
                case "*":
                case "/":
                    return 2;
                case "^":
                    return 3;
                default:
                    return 4;
            }
        }

        public string[] ConvertToPostfixNotation(string input)
        {
            List<string> outputSeparated = new List<string>();
            Stack<string> stack = new Stack<string>();
            foreach (string c in Separate(input))
            {
                if (operators.Contains(c))
                {
                    if (stack.Count > 0 && !c.Equals("("))
                    {
                        if (c.Equals(")"))
                        {
                            string s = stack.Pop();
                            while (s != "(")
                            {
                                outputSeparated.Add(s);
                                s = stack.Pop();
                            }
                        }
                        else if (prefix_operators.Contains(c))
                        {
                            stack.Push(c);
                        }
                        else if (GetPriority(c) > GetPriority(stack.Peek()))
                            stack.Push(c);
                        else
                        {
                            while (stack.Count > 0 && GetPriority(c) <= GetPriority(stack.Peek()))
                                outputSeparated.Add(stack.Pop());
                            stack.Push(c);
                        }
                    }
                    else
                        stack.Push(c);
                }
                else if (c.Equals(" "))
                {

                }
                else
                    outputSeparated.Add(c);
            }
            if (stack.Count > 0)
                foreach (string c in stack)
                    outputSeparated.Add(c);

            return outputSeparated.ToArray();
        }
        public double result(params double[] variableValues)
        {
            Stack<string> stack = new Stack<string>();
            Queue<string> queue = new Queue<string>(PostfixNotation);
            string str = queue.Dequeue();
            while (queue.Count >= 0)
            {
                if (!operators.Contains(str))
                {
                    try
                    {
						double digit;
                        if (constants.Contains(str))
                        {
                            str = constantValues[constants.IndexOf(str)].ToString();
                        }
                        else if (variables.Contains(str))
                        {
                            str = variableValues[variables.IndexOf(str)].ToString();
                        }
                        else if (!double.TryParse(str, out digit))
                        {
                            throw new Exception("Error enter data");
                        }
                        stack.Push(str);
                    }
                    catch (Exception ex)
                    {
                        //MessageBox.Show(ex.Message);
                        return 0;
                    }
                }
                else
                {
                    double summ = 0;
                    try
                    {

                        switch (str)
                        {

                            case "+":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = a + b;
                                    break;
                                }
                            case "-":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b - a;
                                    break;
                                }
                            case "*":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b * a;
                                    break;
                                }
                            case "/":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b / a;
                                    break;
                                }
                            case "^":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Pow(Convert.ToDouble(b), Convert.ToDouble(a)));
                                    break;
                                }
                            case "sin":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Sin(Convert.ToDouble(a)));
                                    break;
                                }
                            case "cos":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Cos(Convert.ToDouble(a)));
                                    break;
                                }
                            case "tg":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Tan(Convert.ToDouble(a)));
                                    break;
                                }
                            case "ctg":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(1 / Math.Tan(Convert.ToDouble(a)));
                                    break;
                                }
                            case "ln":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Log(Convert.ToDouble(a)));
                                    break;
                                }
                            case "log10":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Log10(Convert.ToDouble(a)));
                                    break;
                                }
                            case "exp":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Exp(Convert.ToDouble(a)));
                                    break;
                                }
                            default:
                                {
                                    throw new Exception("Error enter data");

                                }
                        }
                    }
                    catch (Exception ex)
                    {
                        //MessageBox.Show(ex.Message);
                        return 0;
                    }
                    stack.Push(summ.ToString());

                }
                if (queue.Count > 0)
                    str = queue.Dequeue();
                else
                    break;
            }
            return Convert.ToDouble(stack.Pop());
        }
    }
    public class DifferentialEquation
    {
        public double x0;
        public double xn;
        public double n;

        public int N;

        public List<double> y0;


        public List<Function> functions;


        //adamsa
        double u1;
        double u2;
        double u3;

        public DifferentialEquation()
        {
        }

        public DifferentialEquation(double x0, double xn, double n, List<double> y0, List<Function> functions)
        {
            this.x0 = x0;
            this.xn = xn;
            this.n = n;
            this.y0 = y0;
            this.functions = functions;
            this.N = y0.Count;
        }

        public DifferentialEquation(double x0, double xn, double n, List<double> y0, List<Function> functions, double u1, double u2, double u3)
        {
            this.x0 = x0;
            this.xn = xn;
            this.n = n;
            this.y0 = y0;
            this.functions = functions;
            this.N = y0.Count;
            this.u1 = u1;
            this.u2 = u2;
            this.u3 = u3;
        }


        public List<List<Point>> MethodsLobatto()
        {
            List<List<Point>> Points = new List<List<Point>>();
            for (int k = 0; k < N; k++)
            {
                Points.Add(new List<Point>());
                Points[k].Add(new Point(x0, y0[k]));
            }

            double[] b = new double[4] { 1 / (double)12, 5 / (double)12, 5 / (double)12, 1 / (double)12 };
            double[] c = new double[4] { 0, (5 - Math.Sqrt(5)) / (double)10, (5 + Math.Sqrt(5)) / (double)10, 1 };
            double[,] a = new double[4, 4] { { 0, 0, 0, 0 }, { (5 + Math.Sqrt(5)) / (double)60, 1 / (double)6, (15 - 7 * Math.Sqrt(5)) / (double)60, 0 }, { (5 - Math.Sqrt(5)) / (double)60, (15 + 7 * Math.Sqrt(5)) / (double)60, 1 / (double)6, 0 }, { 1 / (double)6, (5 - Math.Sqrt(5)) / (double)12, (5 + Math.Sqrt(5)) / (double)12, 0 } };

            double s = 4;
            double h = (xn - x0) / n;

            double xi = x0;
            List<double> yi = Copy(y0);

            double[] k1 = new double[N];
            double[] k2 = new double[N];
            double[] k3 = new double[N];
            double[] k4 = new double[N];

            while (xi < xn)
            {


                for (int k = 0; k < N; k++)
                {

                    k1[k] = functions[k].result(ToArray(xi, yi));
                    k2[k] = functions[k].result(ToArray(xi, yi));
                    k3[k] = functions[k].result(ToArray(xi, yi));
                    k4[k] = functions[k].result(ToArray(xi, yi));
                }

                double[][] K = new double[4][] { k1, k2, k3, k4 };

                double[,] KPlusOne = new double[4, N];

                double x;
                while (true)
                {
                    for (int j = 0; j < s; j++)
                    {

                        x = xi + h * c[j];

                        List<double> y = new List<double>();
                        for (int k = 0; k < N; k++)
                        {
                            y.Add(new double());
                            y[k] = yi[k];
                            for (int i = 0; i < s; i++)
                            {
                                y[k] += h * a[j, i] * K[i][k];
                            }
                        }

                        for (int k = 0; k < N; k++)
                        {
                            KPlusOne[j, k] = functions[k].result(ToArray(x, y));

                        }

                    }

                    bool isEps = true;
                    double eps = 0.000001;

                    for (int k = 0; k < N; k++)
                    {
                        for (int j = 0; j < s; j++)
                        {
                            if (Math.Abs((KPlusOne[j, k] - K[j][k]) / K[j][k]) > eps) isEps = false;
                        }
                    }

                    if (isEps)
                    {
                        break;
                    }
                    else
                    {
                        for (int k = 0; k < N; k++)
                        {
                            for (int j = 0; j < s; j++)
                            {
                                K[j][k] = KPlusOne[j, k];
                            }
                        }
                    }
                }

                xi = xi + h;
                for (int k = 0; k < N; k++)
                {
                    for (int j = 0; j < s; j++)
                    {
                        yi[k] += h * b[j] * K[j][k];
                    }
                    Points[k].Add(new Point(xi, yi[k]));
                }
            }
            return Points;
        }

        public List<Point> MethodsRungeKutta()
        {

            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}

            List<Point> Points = new List<Point>();

            Points.Add(new Point(x0, y0[0]));

            double h = (xn - x0) / n;

            double xi = x0;
            double yi = y0[0];
            double k1 = 0;
            double k2 = 0;
            double k3 = 0;
            double k4 = 0;
            int i = 0;
            Console.WriteLine("y" + i + "=" + yi);
            Console.WriteLine("x" + i + "=" + xi);
            while (i < n)
            {
                k1 = functions[0].result(xi, yi);
                Console.WriteLine("k1=" + k1);
                k2 = functions[0].result(xi + h / 2, yi + h * k1 / 2);
                Console.WriteLine("k2=" + k2);
                k3 = functions[0].result(xi + h / 2, yi + h * k2 / 2);
                Console.WriteLine("k3=" + k3);
                k4 = functions[0].result(xi + h, yi + h * k3);
                Console.WriteLine("k4=" + k4);
                yi = yi + (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
                Console.WriteLine("y" + (i + 1) + "=" + yi);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                //xi = Math.Round(xi, 8);
                Points.Add(new Point(xi, yi));
                i++;
            }

            return Points;
        }

        public List<Point> MethodsAdamsa()
        {

            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
            int i = 0;
            List<Point> Points = new List<Point>();



            double h = (xn - x0) / n;

            List<double> xi = new List<double>();
            List<double> yi = new List<double>();
            xi.Add(x0);
            yi.Add(y0[0]);
            Console.WriteLine("y0=" + y0[0]);
            Console.WriteLine("x0=" + x0 + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u1);
            Console.WriteLine("y1=" + u1);
            Console.WriteLine("x1=" + xi.Last() + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u2);
            Console.WriteLine("y2=" + u2);
            Console.WriteLine("x2=" + xi.Last() + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u3);
            Console.WriteLine("y3=" + u3);
            Console.WriteLine("x3=" + xi.Last() + "\n");

            Points.Add(new Point(xi.Last(), yi.Last()));
            i = 3;
            while (i < n)
            {
                yi.Add(yi.Last() + (h / 24) * (55 * functions[0].result(xi[i], yi[i]) - 59 * functions[0].result(xi[i - 1], yi[i - 1]) + 37 * functions[0].result(xi[i - 2], yi[i - 2]) - 9 * functions[0].result(xi[i - 3], yi[i - 3])));
                xi.Add(xi.Last() + h);
                Console.WriteLine("y" + (i + 1) + "=" + yi.Last());
                Console.WriteLine("x" + (i + 1) + "=" + xi.Last() + "\n");
                i++;
                Points.Add(new Point(xi.Last(), yi.Last()));
            }

            return Points;
        }

        public List<Point> MethodsEuler()
        {

            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}

            List<Point> Points = new List<Point>();

            Points.Add(new Point(x0, y0[0]));

            double h = (xn - x0) / n;

            double xi = x0;
            double yi = y0[0];
            int i = 0;
            Console.WriteLine("y" + i + "=" + yi);
            Console.WriteLine("x" + i + "=" + xi);
            while (i < n)
            {
                yi = yi + h * functions[0].result(xi, yi);
                Console.WriteLine("y" + (i + 1) + "=" + yi);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                //xi = Math.Round(xi, 8);
                Points.Add(new Point(xi, yi));
                i++;
            }

            return Points;
        }

        public List<double> Copy(List<double> list)
        {
            List<double> listCopy = new List<double>();
            foreach (double digit in list)
            {
                listCopy.Add(digit);
            }
            return listCopy;
        }
        public double[] ToArray(double xi, List<double> yi)
        {
            double[] variableValues = new double[N + 1];
            variableValues[0] = xi;
            for (int i = 0; i < N; i++)
            {
                variableValues[i + 1] = yi[i];
            }
            return variableValues;
        }

        public List<List<Point>> MethodsRungeKutta2()
        {

            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}

            List<List<Point>> Points = new List<List<Point>>();
            Points.Add(new List<Point>());
            Points.Add(new List<Point>());
            Points[0].Add(new Point(x0, y0[0]));
            Points[1].Add(new Point(x0, y0[1]));

            //Points.Add(new Point(x0, y10));


            double h = (xn - x0) / n;

            double xi = x0;
            double y1i = y0[0];
            double y2i = y0[1];

            double y2i0 = y2i;


            double k1 = 0;
            double k2 = 0;
            double k3 = 0;
            double k4 = 0;

            double l1 = 0;
            double l2 = 0;
            double l3 = 0;
            double l4 = 0;
            int i = 0;
            while (xi + 0.0001 < xn)
            {

                k1 = functions[0].result(xi, y1i, y2i);
                Console.WriteLine("k1=" + k1);
                l1 = functions[1].result(xi, y1i, y2i);
                Console.WriteLine("l1=" + l1);
                k2 = functions[0].result(xi + h / 2, y1i + h * k1 / 2, y2i + h * l1 / 2);
                Console.WriteLine("k2=" + k2);
                l2 = functions[1].result(xi + h / 2, y1i + h * k1 / 2, y2i + h * l1 / 2);
                Console.WriteLine("l2=" + l2);
                k3 = functions[0].result(xi + h / 2, y1i + h * k2 / 2, y2i + h * l2 / 2);
                Console.WriteLine("k3=" + k3);
                l3 = functions[1].result(xi + h / 2, y1i + h * k2 / 2, y2i + h * l2 / 2);
                Console.WriteLine("l3=" + l3);
                k4 = functions[0].result(xi + h, y1i + h * k3, y2i + h * l3);
                Console.WriteLine("k4=" + k4);
                l4 = functions[1].result(xi + h, y1i + h * k3, y2i + h * l3);
                Console.WriteLine("l4=" + l4);
                // MessageBox.Show("" + k1 + k2 + k3 + k4);
                // MessageBox.Show("" + l1 + l2 + l3 + l4);
                y1i = y1i + (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
                Console.WriteLine("y" + (i + 1) + "=" + y1i);
                y2i = y2i + (h / 6) * (l1 + 2 * l2 + 2 * l3 + l4);
                Console.WriteLine("z" + (i + 1) + "=" + y2i);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                i++;
                // xi = Math.Round(xi, 8);

                Points[0].Add(new Point(xi, y1i));
                Points[1].Add(new Point(xi, y2i));
            }

            return Points;
        }

        public List<List<Point>> MethodsEuler2()
        {

            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}

            List<List<Point>> Points = new List<List<Point>>();
            Points.Add(new List<Point>());
            Points.Add(new List<Point>());
            Points[0].Add(new Point(x0, y0[0]));
            Points[1].Add(new Point(x0, y0[1]));

            double h = (xn - x0) / n;
            //Console.WriteLine(h);
            double xi = x0;
            double y1i = y0[0];
            double y2i = y0[1];

            double y1i0 = y1i;
            int i = 0;
            while (xi + 0.0001 < xn)
            {
                y1i = y1i + h * functions[0].result(xi, y1i0, y2i);
                Console.WriteLine("y" + (i + 1) + "=" + y1i);
                y2i = y2i + h * functions[1].result(xi, y1i0, y2i);
                Console.WriteLine("z" + (i + 1) + "=" + y2i);

                y1i0 = y1i;
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                i++;
                //xi = Math.Round(xi, 8);
                Points[0].Add(new Point(xi, y1i));
                Points[1].Add(new Point(xi, y2i));
            }

            return Points;
        }
        //public string print(double [] a)
        //{
        //    string p="";
        //    for(int i=0; i<a.Length; i++)
        //    {
        //        p = p +" "+ a[i];
        //    }
        //    return p;
        //}
        //public string print(double[][] a)
        //{
        //    string p = "";
        //    for (int i = 0; i < a.Length; i++)
        //    {
        //        for (int j = 0; j < a[i].Length; j++)
        //        {
        //            p = p + " " + a[i][j];
        //        }     
        //    }
        //    return p;
        //}
        //public string print(double[,] a)
        //{
        //    string p = "";
        //    for (int i = 0; i < a.Length; i++)
        //    {
        //            p = p + " " + a[i,0];
        //    }
        //    return p;
        //}
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Threading.Tasks;
​
namespace ConsoleApp4
{
    public class Program
    { 
        public static void Main(string[] args)
        {
            double x0 = 0;
            double xn = 1;
            int  n = 5;
​
            ///*
            ////////////////////////for one equation
            List<double> y0 = new List<double> { 1.5 };
            List<Function> functions = new List<Function> { new Function("y - x", "x", "y") };
            DifferentialEquation equation = new DifferentialEquation(x0, xn, n, y0, functions, 1.8, 2.12, 2.464);
            //List<Point> result = equation.MethodsEuler();
            //List<Point> result = equation.MethodsRungeKutta();
            List<Point> result = equation.MethodsAdamsa(); 
            //*/
​
            /*
            ///////////////////////for two equations
            List<double> y02 = new List<double> { 2, 3 };
            List<Function> functions2 = new List<Function> { new Function("2*z-3*y", "x", "y", "z"), new Function("z-2*y", "x", "y", "z") }; DifferentialEquation equation2 = new DifferentialEquation(x0, xn, n, y02, functions2);
            List<List<Point>> result2 = equation2.MethodsEuler2();
            // List<List<Point>> result = equation2.MethodsRungeKutta2(); 
            //*/
​
        }
        
    }
    public class Function
    {
        public Function(string str, params string[] variables)
        {
            operators = new List<string>(standart_operators);
            operators.AddRange(prefix_operators);
            this.strFunction = str;
            this.variables = new List<string>(variables);
            PostfixNotation = ConvertToPostfixNotation(strFunction);
        }
​
        public string strFunction;
​
        private List<string> operators;
​
        private List<string> standart_operators =
            new List<string>(new string[] { "(", ")", "+", "-", "*", "/", "^" });
​
        private List<string> prefix_operators =
            new List<string>(new string[] { "cos", "sin", "tg", "ctg", "ln", "log10", "exp" });
​
        string[] PostfixNotation;
​
        private List<string> variables;
​
        private List<string> constants = new List<string>(new string[] { "e", "pi" });
        private List<double> constantValues = new List<double>(new double[] { Math.E, Math.PI });
​
​
        private IEnumerable<string> Separate(string input)
        {
            int pos = 0;
            while (pos < input.Length)
            {
                string s = string.Empty + input[pos];
                if (!standart_operators.Contains(input[pos].ToString()))
                {
                    if (Char.IsDigit(input[pos]))
                        for (int i = pos + 1; i < input.Length &&
                            (Char.IsDigit(input[i]) || input[i] == ',' || input[i] == '.'); i++)
                            s += input[i];
                    else if (Char.IsLetter(input[pos]))
                        for (int i = pos + 1; i < input.Length &&
                            (Char.IsLetter(input[i]) || Char.IsDigit(input[i])); i++)
                            s += input[i];
                }
                yield return s;
                pos += s.Length;
            }
        }
        private byte GetPriority(string s)
        {
            switch (s)
            {
                case "(":
                case ")":
                    return 0;
                case "+":
                case "-":
                    return 1;
                case "*":
                case "/":
                    return 2;
                case "^":
                    return 3;
                default:
                    return 4;
            }
        }
​
        public string[] ConvertToPostfixNotation(string input)
        {
            List<string> outputSeparated = new List<string>();
            Stack<string> stack = new Stack<string>();
            foreach (string c in Separate(input))
            {
                if (operators.Contains(c))
                {
                    if (stack.Count > 0 && !c.Equals("("))
                    {
                        if (c.Equals(")"))
                        {
                            string s = stack.Pop();
                            while (s != "(")
                            {
                                outputSeparated.Add(s);
                                s = stack.Pop();
                            }
                        }
                        else if (prefix_operators.Contains(c))
                        {
                            stack.Push(c);
                        }
                        else if (GetPriority(c) > GetPriority(stack.Peek()))
                            stack.Push(c);
                        else
                        {
                            while (stack.Count > 0 && GetPriority(c) <= GetPriority(stack.Peek()))
                                outputSeparated.Add(stack.Pop());
                            stack.Push(c);
                        }
                    }
                    else
                        stack.Push(c);
                }
                else if (c.Equals(" "))
                {
​
                }
                else
                    outputSeparated.Add(c);
            }
            if (stack.Count > 0)
                foreach (string c in stack)
                    outputSeparated.Add(c);
​
            return outputSeparated.ToArray();
        }
        public double result(params double[] variableValues)
        {
            Stack<string> stack = new Stack<string>();
            Queue<string> queue = new Queue<string>(PostfixNotation);
            string str = queue.Dequeue();
            while (queue.Count >= 0)
            {
                if (!operators.Contains(str))
                {
                    try
                    {
                        double digit;
                        if (constants.Contains(str))
                        {
                            str = constantValues[constants.IndexOf(str)].ToString();
                        }
                        else if (variables.Contains(str))
                        {
                            str = variableValues[variables.IndexOf(str)].ToString();
                        }
                        else if (!double.TryParse(str, out digit))
                        {
                            throw new Exception("Error enter data");
                        }
                        stack.Push(str);
                    }
                    catch (Exception ex)
                    {
                        //MessageBox.Show(ex.Message);
                        return 0;
                    }
                }
                else
                {
                    double summ = 0;
                    try
                    {
​
                        switch (str)
                        {
​
                            case "+":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = a + b;
                                    break;
                                }
                            case "-":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b - a;
                                    break;
                                }
                            case "*":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b * a;
                                    break;
                                }
                            case "/":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = b / a;
                                    break;
                                }
                            case "^":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    double b = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Pow(Convert.ToDouble(b), Convert.ToDouble(a)));
                                    break;
                                }
                            case "sin":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Sin(Convert.ToDouble(a)));
                                    break;
                                }
                            case "cos":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Cos(Convert.ToDouble(a)));
                                    break;
                                }
                            case "tg":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Tan(Convert.ToDouble(a)));
                                    break;
                                }
                            case "ctg":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(1 / Math.Tan(Convert.ToDouble(a)));
                                    break;
                                }
                            case "ln":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Log(Convert.ToDouble(a)));
                                    break;
                                }
                            case "log10":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Log10(Convert.ToDouble(a)));
                                    break;
                                }
                            case "exp":
                                {
                                    double a = Convert.ToDouble(stack.Pop());
                                    summ = Convert.ToDouble(Math.Exp(Convert.ToDouble(a)));
                                    break;
                                }
                            default:
                                {
                                    throw new Exception("Error enter data");
​
                                }
                        }
                    }
                    catch (Exception ex)
                    {
                        //MessageBox.Show(ex.Message);
                        return 0;
                    }
                    stack.Push(summ.ToString());
​
                }
                if (queue.Count > 0)
                    str = queue.Dequeue();
                else
                    break;
            }
            return Convert.ToDouble(stack.Pop());
        }
    }
    public class DifferentialEquation
    {
        public double x0;
        public double xn;
        public double n;
​
        public int N;
​
        public List<double> y0;
​
​
        public List<Function> functions;
​
​
        //adamsa
        double u1;
        double u2;
        double u3;
​
        public DifferentialEquation()
        {
        }
​
        public DifferentialEquation(double x0, double xn, double n, List<double> y0, List<Function> functions)
        {
            this.x0 = x0;
            this.xn = xn;
            this.n = n;
            this.y0 = y0;
            this.functions = functions;
            this.N = y0.Count;
        }
​
        public DifferentialEquation(double x0, double xn, double n, List<double> y0, List<Function> functions, double u1, double u2, double u3)
        {
            this.x0 = x0;
            this.xn = xn;
            this.n = n;
            this.y0 = y0;
            this.functions = functions;
            this.N = y0.Count;
            this.u1 = u1;
            this.u2 = u2;
            this.u3 = u3;
        }
​
​
        public List<List<Point>> MethodsLobatto()
        {
            List<List<Point>> Points = new List<List<Point>>();
            for (int k = 0; k < N; k++)
            {
                Points.Add(new List<Point>());
                Points[k].Add(new Point(x0, y0[k]));
            }
​
            double[] b = new double[4] { 1 / (double)12, 5 / (double)12, 5 / (double)12, 1 / (double)12 };
            double[] c = new double[4] { 0, (5 - Math.Sqrt(5)) / (double)10, (5 + Math.Sqrt(5)) / (double)10, 1 };
            double[,] a = new double[4, 4] { { 0, 0, 0, 0 }, { (5 + Math.Sqrt(5)) / (double)60, 1 / (double)6, (15 - 7 * Math.Sqrt(5)) / (double)60, 0 }, { (5 - Math.Sqrt(5)) / (double)60, (15 + 7 * Math.Sqrt(5)) / (double)60, 1 / (double)6, 0 }, { 1 / (double)6, (5 - Math.Sqrt(5)) / (double)12, (5 + Math.Sqrt(5)) / (double)12, 0 } };
​
            double s = 4;
            double h = (xn - x0) / n;
​
            double xi = x0;
            List<double> yi = Copy(y0);
​
            double[] k1 = new double[N];
            double[] k2 = new double[N];
            double[] k3 = new double[N];
            double[] k4 = new double[N];
​
            while (xi < xn)
            {
​
​
                for (int k = 0; k < N; k++)
                {
​
                    k1[k] = functions[k].result(ToArray(xi, yi));
                    k2[k] = functions[k].result(ToArray(xi, yi));
                    k3[k] = functions[k].result(ToArray(xi, yi));
                    k4[k] = functions[k].result(ToArray(xi, yi));
                }
​
                double[][] K = new double[4][] { k1, k2, k3, k4 };
​
                double[,] KPlusOne = new double[4, N];
​
                double x;
                while (true)
                {
                    for (int j = 0; j < s; j++)
                    {
​
                        x = xi + h * c[j];
​
                        List<double> y = new List<double>();
                        for (int k = 0; k < N; k++)
                        {
                            y.Add(new double());
                            y[k] = yi[k];
                            for (int i = 0; i < s; i++)
                            {
                                y[k] += h * a[j, i] * K[i][k];
                            }
                        }
​
                        for (int k = 0; k < N; k++)
                        {
                            KPlusOne[j, k] = functions[k].result(ToArray(x, y));
​
                        }
​
                    }
​
                    bool isEps = true;
                    double eps = 0.000001;
​
                    for (int k = 0; k < N; k++)
                    {
                        for (int j = 0; j < s; j++)
                        {
                            if (Math.Abs((KPlusOne[j, k] - K[j][k]) / K[j][k]) > eps) isEps = false;
                        }
                    }
​
                    if (isEps)
                    {
                        break;
                    }
                    else
                    {
                        for (int k = 0; k < N; k++)
                        {
                            for (int j = 0; j < s; j++)
                            {
                                K[j][k] = KPlusOne[j, k];
                            }
                        }
                    }
                }
​
                xi = xi + h;
                for (int k = 0; k < N; k++)
                {
                    for (int j = 0; j < s; j++)
                    {
                        yi[k] += h * b[j] * K[j][k];
                    }
                    Points[k].Add(new Point(xi, yi[k]));
                }
            }
            return Points;
        }
​
        public List<Point> MethodsRungeKutta()
        {
​
            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
​
            List<Point> Points = new List<Point>();
​
            Points.Add(new Point(x0, y0[0]));
​
            double h = (xn - x0) / n;
​
            double xi = x0;
            double yi = y0[0];
            double k1 = 0;
            double k2 = 0;
            double k3 = 0;
            double k4 = 0;
            int i = 0;
            Console.WriteLine("y" + i + "=" + yi);
            Console.WriteLine("x" + i + "=" + xi);
            while (i < n)
            {
                k1 = functions[0].result(xi, yi);
                Console.WriteLine("k1=" + k1);
                k2 = functions[0].result(xi + h / 2, yi + h * k1 / 2);
                Console.WriteLine("k2=" + k2);
                k3 = functions[0].result(xi + h / 2, yi + h * k2 / 2);
                Console.WriteLine("k3=" + k3);
                k4 = functions[0].result(xi + h, yi + h * k3);
                Console.WriteLine("k4=" + k4);
                yi = yi + (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
                Console.WriteLine("y" + (i + 1) + "=" + yi);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                //xi = Math.Round(xi, 8);
                Points.Add(new Point(xi, yi));
                i++;
            }
​
            return Points;
        }
​
        public List<Point> MethodsAdamsa()
        {
​
            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
            int i = 0;
            List<Point> Points = new List<Point>();
​
​
​
            double h = (xn - x0) / n;
​
            List<double> xi = new List<double>();
            List<double> yi = new List<double>();
            xi.Add(x0);
            yi.Add(y0[0]);
            Console.WriteLine("y0=" + y0[0]);
            Console.WriteLine("x0=" + x0 + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u1);
            Console.WriteLine("y1=" + u1);
            Console.WriteLine("x1=" + xi.Last() + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u2);
            Console.WriteLine("y2=" + u2);
            Console.WriteLine("x2=" + xi.Last() + "\n");
            Points.Add(new Point(xi.Last(), yi.Last()));
            xi.Add(xi.Last() + h);
            yi.Add(u3);
            Console.WriteLine("y3=" + u3);
            Console.WriteLine("x3=" + xi.Last() + "\n");
​
            Points.Add(new Point(xi.Last(), yi.Last()));
            i = 3;
            while (i < n)
            {
                yi.Add(yi.Last() + (h / 24) * (55 * functions[0].result(xi[i], yi[i]) - 59 * functions[0].result(xi[i - 1], yi[i - 1]) + 37 * functions[0].result(xi[i - 2], yi[i - 2]) - 9 * functions[0].result(xi[i - 3], yi[i - 3])));
                xi.Add(xi.Last() + h);
                Console.WriteLine("y" + (i + 1) + "=" + yi.Last());
                Console.WriteLine("x" + (i + 1) + "=" + xi.Last() + "\n");
                i++;
                Points.Add(new Point(xi.Last(), yi.Last()));
            }
​
            return Points;
        }
​
        public List<Point> MethodsEuler()
        {
​
            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
​
            List<Point> Points = new List<Point>();
​
            Points.Add(new Point(x0, y0[0]));
​
            double h = (xn - x0) / n;
​
            double xi = x0;
            double yi = y0[0];
            int i = 0;
            Console.WriteLine("y" + i + "=" + yi);
            Console.WriteLine("x" + i + "=" + xi);
            while (i < n)
            {
                yi = yi + h * functions[0].result(xi, yi);
                Console.WriteLine("y" + (i + 1) + "=" + yi);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                //xi = Math.Round(xi, 8);
                Points.Add(new Point(xi, yi));
                i++;
            }
​
            return Points;
        }
​
        public List<double> Copy(List<double> list)
        {
            List<double> listCopy = new List<double>();
            foreach (double digit in list)
            {
                listCopy.Add(digit);
            }
            return listCopy;
        }
        public double[] ToArray(double xi, List<double> yi)
        {
            double[] variableValues = new double[N + 1];
            variableValues[0] = xi;
            for (int i = 0; i < N; i++)
            {
                variableValues[i + 1] = yi[i];
            }
            return variableValues;
        }
​
        public List<List<Point>> MethodsRungeKutta2()
        {
​
            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
​
            List<List<Point>> Points = new List<List<Point>>();
            Points.Add(new List<Point>());
            Points.Add(new List<Point>());
            Points[0].Add(new Point(x0, y0[0]));
            Points[1].Add(new Point(x0, y0[1]));
​
            //Points.Add(new Point(x0, y10));
​
​
            double h = (xn - x0) / n;
​
            double xi = x0;
            double y1i = y0[0];
            double y2i = y0[1];
​
            double y2i0 = y2i;
​
​
            double k1 = 0;
            double k2 = 0;
            double k3 = 0;
            double k4 = 0;
​
            double l1 = 0;
            double l2 = 0;
            double l3 = 0;
            double l4 = 0;
            int i = 0;
            while (xi + 0.0001 < xn)
            {
​
                k1 = functions[0].result(xi, y1i, y2i);
                Console.WriteLine("k1=" + k1);
                l1 = functions[1].result(xi, y1i, y2i);
                Console.WriteLine("l1=" + l1);
                k2 = functions[0].result(xi + h / 2, y1i + h * k1 / 2, y2i + h * l1 / 2);
                Console.WriteLine("k2=" + k2);
                l2 = functions[1].result(xi + h / 2, y1i + h * k1 / 2, y2i + h * l1 / 2);
                Console.WriteLine("l2=" + l2);
                k3 = functions[0].result(xi + h / 2, y1i + h * k2 / 2, y2i + h * l2 / 2);
                Console.WriteLine("k3=" + k3);
                l3 = functions[1].result(xi + h / 2, y1i + h * k2 / 2, y2i + h * l2 / 2);
                Console.WriteLine("l3=" + l3);
                k4 = functions[0].result(xi + h, y1i + h * k3, y2i + h * l3);
                Console.WriteLine("k4=" + k4);
                l4 = functions[1].result(xi + h, y1i + h * k3, y2i + h * l3);
                Console.WriteLine("l4=" + l4);
                // MessageBox.Show("" + k1 + k2 + k3 + k4);
                // MessageBox.Show("" + l1 + l2 + l3 + l4);
                y1i = y1i + (h / 6) * (k1 + 2 * k2 + 2 * k3 + k4);
                Console.WriteLine("y" + (i + 1) + "=" + y1i);
                y2i = y2i + (h / 6) * (l1 + 2 * l2 + 2 * l3 + l4);
                Console.WriteLine("z" + (i + 1) + "=" + y2i);
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                i++;
                // xi = Math.Round(xi, 8);
​
                Points[0].Add(new Point(xi, y1i));
                Points[1].Add(new Point(xi, y2i));
            }
​
            return Points;
        }
​
        public List<List<Point>> MethodsEuler2()
        {
​
            //if(x0 > xn)
            //{
            //    throw new Exception("Не правильні початкові дані");
            //}
​
            List<List<Point>> Points = new List<List<Point>>();
            Points.Add(new List<Point>());
            Points.Add(new List<Point>());
            Points[0].Add(new Point(x0, y0[0]));
            Points[1].Add(new Point(x0, y0[1]));
​
            double h = (xn - x0) / n;
            //Console.WriteLine(h);
            double xi = x0;
            double y1i = y0[0];
            double y2i = y0[1];
​
            double y1i0 = y1i;
            int i = 0;
            while (xi + 0.0001 < xn)
            {
                y1i = y1i + h * functions[0].result(xi, y1i0, y2i);
                Console.WriteLine("y" + (i + 1) + "=" + y1i);
                y2i = y2i + h * functions[1].result(xi, y1i0, y2i);
                Console.WriteLine("z" + (i + 1) + "=" + y2i);
​
                y1i0 = y1i;
                xi = xi + h;
                Console.WriteLine("x" + (i + 1) + "=" + xi + "\n");
                i++;
                //xi = Math.Round(xi, 8);
                Points[0].Add(new Point(xi, y1i));
                Points[1].Add(new Point(xi, y2i));
            }
​
            return Points;
        }
        //public string print(double [] a)
        //{
        //    string p="";
        //    for(int i=0; i<a.Length; i++)
        //    {
        //        p = p +" "+ a[i];
        //    }
        //    return p;
        //}
        //public string print(double[][] a)
        //{
        //    string p = "";
        //    for (int i = 0; i < a.Length; i++)
        //    {
        //        for (int j = 0; j < a[i].Length; j++)
        //        {
        //            p = p + " " + a[i][j];
        //        }     
        //    }
        //    return p;
        //}
        //public string print(double[,] a)
        //{
        //    string p = "";
        //    for (int i = 0; i < a.Length; i++)
        //    {
        //            p = p + " " + a[i,0];
        //    }
        //    return p;
        //}
    }
}
​

View IL Code