Пример #1
0
        public static double Polynomial(Point[] p, double x)
        {
            double y = 0;

            double[,] a = new double[p.Length, p.Length];
            for (int row = 0; row < a.GetLength(0); row++)
            {
                for (int col = 0; col < a.GetLength(1); col++)
                {
                    a[row, col] = Math.Pow(p[row].X, col);
                }
            }
            double[] b = new double[p.Length];
            for (int i = 0; i < b.Length; i++)
            {
                b[i] = p[i].Y;
            }
            double[] c = LinearSystem.SolveByInvertMatrix(a, b);
            for (int i = 0; i < c.Length; i++)
            {
                y += c[i] * Math.Pow(x, i);
            }
            return(y);
        }
Пример #2
0
        public static void Calculate()
        {
            try
            {
                string command = GetCommand();
                if (command == "/calc")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Арифметический калькулятор===---",
                                          "Доступные операции: + - * / ^",
                                          "Доступно использование круглых скобок и констант:",
                                          "p = 3,14159 (число Пи)",
                                          "e = 2,71828 (число Эйлера)"
                                          ));
                    PrintNumber(Arithmetic.Solve(GetExpression()));
                }
                else if (command == "/vec")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Векторы===---",
                                          "Доступные действия:",
                                          "v+v - сложение векторов",
                                          "v-v - вычитание векторов",
                                          "v*n - умножение вектора на число",
                                          "v*v - скалярное произведение векторов",
                                          "len - длина вектора"));
                    Write("Действие: ");
                    int      vectorSize;
                    double[] v1, v2;
                    switch (GetInput().Trim(' ').ToLower())
                    {
                    case "v+v":
                        vectorSize = GetVectorSize();
                        v1         = GetVector("1", vectorSize);
                        v2         = GetVector("2", vectorSize);
                        PrintVector(Vector.AddVectorToVector(v1, v2));
                        break;

                    case "v-v":
                        vectorSize = GetVectorSize();
                        v1         = GetVector("1", vectorSize);
                        v2         = GetVector("2", vectorSize);
                        PrintVector(Vector.DeductVectorFromVector(v1, v2));
                        break;

                    case "v*n":
                        v1 = GetVector();
                        double n = GetNumber();
                        PrintVector(Vector.MultiplyVectorToNumber(v1, n));
                        break;

                    case "v*v":
                        vectorSize = GetVectorSize();
                        v1         = GetVector("1", vectorSize);
                        v2         = GetVector("2", vectorSize);
                        PrintNumber(Vector.MultiplyScalar(v1, v2));
                        break;

                    case "len":
                        v1 = GetVector();
                        PrintNumber(Vector.GetVectorLength(v1));
                        break;
                    }
                }
                else if (command == "/mat")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Матрицы===---",
                                          "Доступные действия:",
                                          "m+m - сложение матриц",
                                          "m-m - вычитание матриц",
                                          "m*n - умножение матрицы на число",
                                          "m*v - умножение матрицы на вектор",
                                          "m*m - умножение матрицы на матрицу",
                                          "trans - транспонирование матрицы",
                                          "det - определитель матрицы",
                                          "inv - обратная матрица"));
                    Write("Действие: ");
                    double[,] m1, m2;
                    switch (GetInput().Trim(' ').ToLower())
                    {
                    case "m+m":
                        m1 = GetMatrix("1");
                        m2 = GetMatrix("2");
                        PrintMatrix(Matrix.AddMatrixToMatrix(m1, m2));
                        break;

                    case "m-m":
                        m1 = GetMatrix("1");
                        m2 = GetMatrix("2");
                        PrintMatrix(Matrix.DeductMatrixFromMatrix(m1, m2));
                        break;

                    case "m*n":
                        m1 = GetMatrix();
                        double n = GetNumber();
                        PrintMatrix(Matrix.MultiplyMatrixToNumber(m1, n));
                        break;

                    case "m*v":
                        m1 = GetMatrix();
                        double[] v = GetVector();
                        PrintVector(Matrix.MultiplyMatrixToVector(m1, v));
                        break;

                    case "m*m":
                        m1 = GetMatrix("1");
                        m2 = GetMatrix("2");
                        PrintMatrix(Matrix.MultiplyMatrixToMatrix(m1, m2));
                        break;

                    case "trans":
                        m1 = GetMatrix();
                        PrintMatrix(Matrix.GetTransposeMatrix(m1));
                        break;

                    case "det":
                        m1 = GetMatrix();
                        PrintNumber(Matrix.GetDeterminant(m1));
                        break;

                    case "inv":
                        m1 = GetMatrix();
                        PrintMatrix(Matrix.GetInvertMatrix(m1));
                        break;
                    }
                }
                else if (command == "/lin")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===СЛАУ===---",
                                          "Доступные действия:",
                                          "inv - решить СЛАУ методом обратной матрицы",
                                          "iter - решить СЛАУ методом простой итерации",
                                          "gauss - решить СЛАУ методом Гаусса"));
                    Write("Действие: ");
                    double[,] a;
                    double[] b;
                    switch (GetInput().Trim(' ').ToLower())
                    {
                    case "inv":
                        a = GetMatrix("коэффициентов");
                        b = GetVector("свободных членов", a.GetLength(0));
                        PrintVector(LinearSystem.SolveByInvertMatrix(a, b));
                        break;

                    case "iter":
                        a = GetMatrix("коэффициентов");
                        b = GetVector("свободных членов", a.GetLength(0));
                        PrintVector(LinearSystem.SolveByIteration(LinearSystem.ConvertToExtendedMatrix(a, b)));
                        break;

                    case "gauss":
                        a = GetMatrix("коэффициентов");
                        b = GetVector("свободных членов", a.GetLength(0));
                        PrintVector(LinearSystem.SolveByGauss(LinearSystem.ConvertToExtendedMatrix(a, b)));
                        break;
                    }
                }
                else if (command == "/nlin")
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Внимание!");
                    Console.WriteLine("Отсутствует автоматическая проверка на сходимость методов");
                    Console.WriteLine("Возможно образование бесконечного цикла");
                    Console.ForegroundColor = ConsoleColor.White;
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Нелинейные уравнения===---",
                                          "Доступные действия:",
                                          "q - решить квадратное уравнение",
                                          "bis - решить нелинейное уравнение методом половинного деления",
                                          "ch - решить нелинейное уравнение методом хорд",
                                          "new - решить нелинейное уравнение методом Ньютона"));
                    Write("Действие: ");
                    double a;
                    double b;
                    switch (GetInput().Trim(' ').ToLower())
                    {
                    case "q":
                        WriteLine("Коэффициенты квадратного уравнения ax^2+bx+c=0:");
                        a = GetNumber("a");
                        b = GetNumber("b");
                        double c = GetNumber("c");
                        WriteLine(AlgebraicEquations.GetRoots(a, b, c));
                        break;

                    case "bis":
                        WriteLine("Интервал [a, b]:");
                        a = GetNumber("a");
                        b = GetNumber("b");
                        PrintNumber(AlgebraicEquations.SolveByBisection(a, b));
                        break;

                    case "ch":
                        WriteLine("Интервал [a, b]:");
                        a = GetNumber("a");
                        b = GetNumber("b");
                        PrintNumber(AlgebraicEquations.SolveByChords(a, b));
                        break;

                    case "new":
                        WriteLine("Интервал [a, b]:");
                        a = GetNumber("a");
                        b = GetNumber("b");
                        PrintNumber(AlgebraicEquations.SolveByNewtone(a, b));
                        break;
                    }
                }
                else if (command == "/int")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Интерполяция===---",
                                          "Доступные действия:",
                                          "near - интерполяция методом ближайшего соседа",
                                          "lin - линейная интерполяция",
                                          "poly - полиномиальная интерполяция"));
                    Write("Действие: ");
                    Point[] p;
                    double  x;
                    switch (GetInput().Trim(' ').ToLower())
                    {
                    case "near":
                        p = GetPoints();
                        x = GetNumber("X");
                        PrintNumber(Interpolation.NearestNeighbor(p, x));
                        break;

                    case "lin":
                        p = GetPoints();
                        x = GetNumber("X");
                        PrintNumber(Interpolation.Linear(p, x));
                        break;

                    case "poly":
                        p = GetPoints();
                        x = GetNumber("X");
                        PrintNumber(Interpolation.Polynomial(p, x));
                        break;
                    }
                }
                else if (command == "/ex")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "---===Примеры ввода===---",
                                          "Задача:",
                                          "Найти корень из 2+3*2 с помощью арифметического калькулятора",
                                          "Ввод: (2+3*2)^(1/2)",
                                          string.Empty,
                                          "Задача:",
                                          "Возвести экспоненту (число Эйлера) во вторую степень",
                                          "с помощью арифметического калькулятора",
                                          "Ввод: e^2",
                                          string.Empty,
                                          "Задача:",
                                          "Ввести произвольную матрицу 2х3",
                                          "Ввод:",
                                          "1: -23,2 -31 351",
                                          "2: 244,04 0,2 -1,5",
                                          string.Empty,
                                          "Задача:",
                                          "Ввести точки с координатами (4; -1,5) (2; 5) (0,7; -3)",
                                          "Ввод:",
                                          "1: 4 -1,5",
                                          "2: 2 5",
                                          "3: 0,7 -3"));
                }
                else if (command == "/nan")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "NaN (англ. Not-a-Number, «нечисло») — одно из особых состояний числа с",
                                          "плавающей запятой. Данное состояние может возникнуть в различных случаях,",
                                          "например, когда предыдущая математическая операция завершилась с неопределённым",
                                          "результатом или если в ячейку памяти попало не удовлетворяющее условиям число",
                                          string.Empty,
                                          "Операции, приводящие к появлению NaN в качестве ответа:",
                                          "1. Все математические операции, содержащие NaN в качестве одного из операндов",
                                          "2. Деление нуля на ноль",
                                          "3. Деление бесконечности на бесконечность",
                                          "4. Умножение нуля на бесконечность",
                                          "5. Сложение бесконечности с бесконечностью противоположного знака",
                                          "6. Вычисление квадратного корня отрицательного числа",
                                          "7. Логарифмирование отрицательного числа",
                                          string.Empty,
                                          "Метод возведения в степень Math.Pow(x, y) или x^y возвращает NaN, если:",
                                          "x < 0, но не -бесконечность",
                                          "y = не целое число, -бесконечность или бесконечность"));
                }
                else if (command == "/help")
                {
                    WriteLine(String.Join(Environment.NewLine,
                                          "Список команд:",
                                          "/calc - арифметические операции",
                                          "/vec - операции с векторами",
                                          "/mat - операции с матрицами",
                                          "/lin - операции с системами линейных алгебраических уравнений",
                                          "/nlin - операции с нелинейными уравнениями",
                                          "/int - интерполяция",
                                          "/ex - примеры ввода",
                                          "/nan - что такое NaN?",
                                          "/clr - очистить консоль",
                                          "/q - выход"
                                          ));
                }
                else if (command == "/clr")
                {
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    WriteLine("\"Console Calculator\" by Bogdan Nikolaev (IT-36a, NTU \"KhPI\")");
                }
                else if (command == "/q")
                {
                    Environment.Exit(0);
                }
                else
                {
                    WriteLine("Команда не найдена (/help)");
                }
            }
            catch (Exception e)
            {
                PrintException(e.Message);
            }
        }