Визуальное програмирование, программа для построения графиков функции

#pragma once
 
#include<cmath>
 
 
 
namespace Lab4 {
 
    using namespace System;
    using namespace System::ComponentModel;
    using namespace System::Collections;
    using namespace System::Windows::Forms;
    using namespace System::Data;
    using namespace System::Drawing;
    using namespace System::Windows::Forms::DataVisualization::Charting;
    /// <summary>
    /// Сводка для Form1
    /// </summary>
    public ref class Form1 : public System::Windows::Forms::Form
    {
    public:
        Form1(void)
        {
            InitializeComponent();
            //
            //TODO: добавьте код конструктора
            //
        }
 
    protected:
        /// <summary>
        /// Освободить все используемые ресурсы.
        /// </summary>
        ~Form1()
        {
            if (components)
            {
                delete components;
            }
        }
    private: System::Windows::Forms::Label^  label1;
    protected: 
 
    private: System::Windows::Forms::Label^  label2;
    private: System::Windows::Forms::Label^  label3;
    private: System::Windows::Forms::Label^  label4;
    private: System::Windows::Forms::Label^  label5;
    private: System::Windows::Forms::TextBox^  textBox1;
    private: System::Windows::Forms::TextBox^  textBox2;
    private: System::Windows::Forms::TextBox^  textBox3;
    private: System::Windows::Forms::Button^  button1;
    private: System::Windows::Forms::Button^  button2;
 
    private: System::Windows::Forms::DataVisualization::Charting::Chart^  chart1;
    private: System::Windows::Forms::TextBox^  textBox4;
 
    private:
        /// <summary>
        /// Требуется переменная конструктора.
        /// </summary>
        System::ComponentModel::Container ^components;
 
#pragma region Windows Form Designer generated code
        /// <summary>
        /// Обязательный метод для поддержки конструктора - не изменяйте
        /// содержимое данного метода при помощи редактора кода.
        /// </summary>
        void InitializeComponent(void)
        {
            System::Windows::Forms::DataVisualization::Charting::ChartArea^  chartArea1 = (gcnew System::Windows::Forms::DataVisualization::Charting::ChartArea());
            System::Windows::Forms::DataVisualization::Charting::Legend^  legend1 = (gcnew System::Windows::Forms::DataVisualization::Charting::Legend());
            System::Windows::Forms::DataVisualization::Charting::Series^  series1 = (gcnew System::Windows::Forms::DataVisualization::Charting::Series());
            System::Windows::Forms::DataVisualization::Charting::Series^  series2 = (gcnew System::Windows::Forms::DataVisualization::Charting::Series());
            System::Windows::Forms::DataVisualization::Charting::Series^  series3 = (gcnew System::Windows::Forms::DataVisualization::Charting::Series());
            this->label1 = (gcnew System::Windows::Forms::Label());
            this->label2 = (gcnew System::Windows::Forms::Label());
            this->label3 = (gcnew System::Windows::Forms::Label());
            this->label4 = (gcnew System::Windows::Forms::Label());
            this->label5 = (gcnew System::Windows::Forms::Label());
            this->textBox1 = (gcnew System::Windows::Forms::TextBox());
            this->textBox2 = (gcnew System::Windows::Forms::TextBox());
            this->textBox3 = (gcnew System::Windows::Forms::TextBox());
            this->button1 = (gcnew System::Windows::Forms::Button());
            this->button2 = (gcnew System::Windows::Forms::Button());
            this->chart1 = (gcnew System::Windows::Forms::DataVisualization::Charting::Chart());
            this->textBox4 = (gcnew System::Windows::Forms::TextBox());
            (cli::safe_cast<System::ComponentModel::ISupportInitialize^  >(this->chart1))->BeginInit();
            this->SuspendLayout();
            // 
            // label1
            // 
            this->label1->AutoSize = true;
            this->label1->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 12, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, 
                static_cast<System::Byte>(204)));
            this->label1->Location = System::Drawing::Point(124, 9);
            this->label1->Name = L"label1";
            this->label1->Size = System::Drawing::Size(443, 20);
            this->label1->TabIndex = 0;
            this->label1->Text = L"Построение графика функции на интервале [xn;xk]";
            // 
            // label2
            // 
            this->label2->AutoSize = true;
            this->label2->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, 
                static_cast<System::Byte>(204)));
            this->label2->Location = System::Drawing::Point(481, 42);
            this->label2->Name = L"label2";
            this->label2->Size = System::Drawing::Size(130, 16);
            this->label2->TabIndex = 2;
            this->label2->Text = L"Введите данные";
            // 
            // label3
            // 
            this->label3->AutoSize = true;
            this->label3->Location = System::Drawing::Point(469, 64);
            this->label3->Name = L"label3";
            this->label3->Size = System::Drawing::Size(73, 13);
            this->label3->TabIndex = 3;
            this->label3->Text = L"Введите ХN=";
            // 
            // label4
            // 
            this->label4->AutoSize = true;
            this->label4->Location = System::Drawing::Point(469, 88);
            this->label4->Name = L"label4";
            this->label4->Size = System::Drawing::Size(72, 13);
            this->label4->TabIndex = 4;
            this->label4->Text = L"Введите ХK=";
            // 
            // label5
            // 
            this->label5->AutoSize = true;
            this->label5->Location = System::Drawing::Point(469, 111);
            this->label5->Name = L"label5";
            this->label5->Size = System::Drawing::Size(73, 13);
            this->label5->TabIndex = 5;
            this->label5->Text = L"Введите XH=";
            // 
            // textBox1
            // 
            this->textBox1->Location = System::Drawing::Point(547, 61);
            this->textBox1->Name = L"textBox1";
            this->textBox1->Size = System::Drawing::Size(64, 20);
            this->textBox1->TabIndex = 6;
            this->textBox1->Text = L"-10";
            // 
            // textBox2
            // 
            this->textBox2->Location = System::Drawing::Point(547, 85);
            this->textBox2->Name = L"textBox2";
            this->textBox2->Size = System::Drawing::Size(64, 20);
            this->textBox2->TabIndex = 7;
            this->textBox2->Text = L"10";
            // 
            // textBox3
            // 
            this->textBox3->Location = System::Drawing::Point(547, 108);
            this->textBox3->Name = L"textBox3";
            this->textBox3->Size = System::Drawing::Size(64, 20);
            this->textBox3->TabIndex = 8;
            this->textBox3->Text = L"0,01";
            // 
            // button1
            // 
            this->button1->Location = System::Drawing::Point(12, 286);
            this->button1->Name = L"button1";
            this->button1->Size = System::Drawing::Size(191, 27);
            this->button1->TabIndex = 9;
            this->button1->Text = L"Нарисовать график";
            this->button1->UseVisualStyleBackColor = true;
            this->button1->Click += gcnew System::EventHandler(this, &Form1::button1_Click);
            // 
            // button2
            // 
            this->button2->Location = System::Drawing::Point(484, 286);
            this->button2->Name = L"button2";
            this->button2->Size = System::Drawing::Size(121, 27);
            this->button2->TabIndex = 10;
            this->button2->Text = L"Выход";
            this->button2->UseVisualStyleBackColor = true;
            this->button2->Click += gcnew System::EventHandler(this, &Form1::button2_Click);
            // 
            // chart1
            // 
            chartArea1->Name = L"ChartArea1";
            this->chart1->ChartAreas->Add(chartArea1);
            legend1->Name = L"Legend1";
            this->chart1->Legends->Add(legend1);
            this->chart1->Location = System::Drawing::Point(0, 151);
            this->chart1->Name = L"chart1";
            series1->BorderColor = System::Drawing::Color::Red;
            series1->BorderWidth = 5;
            series1->ChartArea = L"ChartArea1";
            series1->ChartType = System::Windows::Forms::DataVisualization::Charting::SeriesChartType::Spline;
            series1->Color = System::Drawing::Color::Red;
            series1->IsVisibleInLegend = false;
            series1->Legend = L"Legend1";
            series1->Name = L"Series1";
            series1->XValueType = System::Windows::Forms::DataVisualization::Charting::ChartValueType::Double;
            series1->YValueType = System::Windows::Forms::DataVisualization::Charting::ChartValueType::Double;
            series2->BorderColor = System::Drawing::Color::Red;
            series2->BorderWidth = 5;
            series2->ChartArea = L"ChartArea1";
            series2->ChartType = System::Windows::Forms::DataVisualization::Charting::SeriesChartType::Spline;
            series2->Color = System::Drawing::Color::FromArgb(static_cast<System::Int32>(static_cast<System::Byte>(0)), static_cast<System::Int32>(static_cast<System::Byte>(0)), 
                static_cast<System::Int32>(static_cast<System::Byte>(192)));
            series2->IsVisibleInLegend = false;
            series2->Legend = L"Legend1";
            series2->Name = L"Series2";
            series3->BorderWidth = 5;
            series3->ChartArea = L"ChartArea1";
            series3->ChartType = System::Windows::Forms::DataVisualization::Charting::SeriesChartType::Spline;
            series3->Color = System::Drawing::Color::Green;
            series3->IsVisibleInLegend = false;
            series3->Legend = L"Legend1";
            series3->Name = L"Series3";
            this->chart1->Series->Add(series1);
            this->chart1->Series->Add(series2);
            this->chart1->Series->Add(series3);
            this->chart1->Size = System::Drawing::Size(605, 129);
            this->chart1->TabIndex = 12;
            this->chart1->Text = L"chart1";
            // 
            // textBox4
            // 
            this->textBox4->Location = System::Drawing::Point(61, 49);
            this->textBox4->Name = L"textBox4";
            this->textBox4->Size = System::Drawing::Size(330, 20);
            this->textBox4->TabIndex = 13;
            // 
            // Form1
            // 
            this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
            this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
            this->ClientSize = System::Drawing::Size(618, 328);
            this->Controls->Add(this->textBox4);
            this->Controls->Add(this->chart1);
            this->Controls->Add(this->button2);
            this->Controls->Add(this->button1);
            this->Controls->Add(this->textBox3);
            this->Controls->Add(this->textBox2);
            this->Controls->Add(this->textBox1);
            this->Controls->Add(this->label5);
            this->Controls->Add(this->label4);
            this->Controls->Add(this->label3);
            this->Controls->Add(this->label2);
            this->Controls->Add(this->label1);
            this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedToolWindow;
            this->Name = L"Form1";
            this->Text = L"Выполнил студент группы ЭСА-11-1 Иванов А.Д. Лабораторная работа 4";
            this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load);
            (cli::safe_cast<System::ComponentModel::ISupportInitialize^  >(this->chart1))->EndInit();
            this->ResumeLayout(false);
            this->PerformLayout();
 
        }
#pragma endregion
    
private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
             
double x,xn,xk,xh,y;
Series^ plot1 = chart1->Series[0];
Series^ plot2 = chart1->Series[1];
Series^ plot3 = chart1->Series[2];
//Очистка компонента Chart1
plot1->Points->Clear();
plot2->Points->Clear();
plot3->Points->Clear();
//Проверка, что введены данные xn, xk, xh и их преобразование в переменные типа Double
if((textBox1->Text!="")&&(textBox2->Text!="")
&&(textBox3->Text!=""))
{
xn = Convert::ToDouble(textBox1->Text);
xk = Convert::ToDouble(textBox2->Text);
xh = Convert::ToDouble(textBox3->Text); 
//Проверка правильности ввода данных
if ((xn>=xk)||(xh>(xk-xn))) 
    { 
MessageBox::Show( "Данные заполнены неверно", "Ошибка       ввода данных",MessageBoxButtons::OK,       MessageBoxIcon::Exclamation );
    } 
else
    {x=xn;
    while (x<=xk) 
    {if (x<=0) {y=x*x+1; plot1->Points->AddXY(x, y);}
else 
    if (x>0&&x<5) {y=cos(x-1);plot2->Points->AddXY(x, y);} 
    else {y=sqrt(x*x*x+2);plot3->Points->AddXY(x, y);}
//Нанесение точки с координатами Х и У в компоненте Chart1
 
        x=x+xh;
       }}
}
else
{
MessageBox::Show( "Заполните, пожалуйста, данные", "Ошибка    ввода данных", MessageBoxButtons::OK, MessageBoxIcon::Exclamation);
}
 
 
         }
private: System::Void button2_Click(System::Object^  sender, System::EventArgs^  e) {Application ::Exit();
         }
 
private: System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) {
         }
};
}

#include <stdio.h>/*библиотека ввoда-вывода*/
#include <conio.h>/*Нужна функция getch()*/
#include <stdlib.h>/*malloc*/
#include <ctype.h>/*tolower*/
#include <string.h>
 
 
/*Ввод выражения*/
void input(char **inputLine)
{
    int iCounter = 0,charSize = sizeof(char);
    char pernor = 0;
    while ( ((pernor = getchar()) != '\n') && (pernor != '\r') && (pernor != EOF) )
    {
        *inputLine = (char *) realloc(*inputLine , charSize*(iCounter+1));
        (*inputLine)[iCounter++] = pernor;
    }
    *inputLine = (char *) realloc(*inputLine , charSize*(iCounter+1));
    (*inputLine)[iCounter++] = '\0';
}
 
/*удаление элементов из массива типа char*/
void shift(char line[],int startNumber, int shiftCount)
{
    while (line[startNumber+shiftCount]!='\0')
    {
        line[startNumber] = line[startNumber+shiftCount];
        line[startNumber+shiftCount] = ' ';
        startNumber++;
    }
    line[startNumber] = '\0';
}
 
/*Удаление лишних символов (не операций и не чисел)*/
void wasteSymbolDelete(char inLine[], int *error)
{
    int iCount = 0;
    char pernor;
 
    while (inLine[iCount] != '\0')
    {
        pernor = inLine[iCount++];
 
        switch (pernor)
        {
        case ')':
        case '(':
        case 'C':
        case 'L':
        case 'S':
        case '.':
        case ',':
        case '+':
        case '*':
        case '-':
        case '/':
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            {
                break;
            }
        default:
            {           
                shift(inLine,--iCount,1);
                *error = 1;
            }
            break;
        }
    }
}
 
/*Подсчет скобок*/
void bracketsCount(char *inputLine, int *error)
{
    int iCounter = 0, jCounter = 0;;
    while ((inputLine[iCounter] != '\0')&&(!*error))
    {
        if (inputLine[iCounter] == '(')
        {
            jCounter++;
        }
        if (inputLine[iCounter] == ')')
        {
            jCounter--;
        }
        if (jCounter<0)
        {
            *error = 1;
        }
        iCounter++;
    }
 
    if (jCounter)
    {
        *error = 1;
    }
 
}
 
/*Выявление наличия целой и дробной части*/
void singlePoint(char *inputLine, int *error)
{
    int iCounter = 1;
    
    while (inputLine[iCounter] != '\0')/*проверка "одинокой" точки*/
    {
        int tempOne,tempTwo;
        tempOne = isdigit( inputLine[iCounter-1]);
        tempTwo = isdigit( inputLine[iCounter+1]);
        if (((inputLine[iCounter] == ',')||(inputLine[iCounter] == '.'))&&(((!tempOne)||(!tempTwo))||(inputLine[iCounter+1] == '\0')))
            *error = 1;
        iCounter++;
    }
 
    if ((inputLine[0] == '.')||(inputLine[0] == ','))
        *error = 1;
}
 
/*Выдает ID символа в системе последовательности. Применяется для опредлеия верности ввода выражения*/
int symbolID(char symbol)
{
    int answer = 0;
 
    switch (symbol)
    {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        {
            answer = 1;
            break;
        }
    case '.':
    case ',':
        {
            answer = 2;
            break;
        }
    case '(':
        {
            answer = 3;
            break;
        }
    case ')':
        {
            answer = 4;
            break;
        }
 
    case '/':
    case '*':
        {
            answer = 7;
            break;
        }
    case '+':
    case '-':
        {
            answer = 6;
            break;
        }
    case 'S':
    case 'C':
    case 'L':
        {
            answer = 5;
            break;
        }
    }
 
    return answer;
}
 
/*фуекция определяет, возможна ли такая последовательночть символов в выражении*/
int correctInput(char firstSymbol, char secondSymbol)
{
    int sequence = symbolID(firstSymbol)*10+symbolID(secondSymbol), answer = 0;
 
    switch (sequence)
    {
    case 11:
    case 12:
    case 14:
    case 16:
    case 17:
    case 21:
    case 31:
    case 33:
    case 35:
    case 36:
    case 44:
    case 46:
    case 47:
    case 53:
    case 61:
    case 63:
    case 71:
    case 73:
    case 75:
        {
            break;
        }
    default:
        {
            answer = 1;
            break;
        }
 
    }
 
    return answer;
 
}
 
/*определение вeрности ввода выражения*/
void inputSequence(char *inputLine, int *error)
{
    int iCounter = 1;
    while (inputLine[iCounter] != '\0')
    {
        if (correctInput(inputLine[iCounter-1],inputLine[iCounter]))
        {
            *error = 1;
            break;
        }
        iCounter++;
    }
}
 
void onlyOnePoint(char *inLine,int *error)
{
    int iCount = 0,pointCount = 0;
    char pernor;
 
    while (inLine[iCount] != '\0')
    {
        pernor = inLine[iCount++];
        switch (pernor)
        {
        case '?':
            {
                pointCount = 0;
                break;
            }
        case '.':
        case ',':
            {
                pointCount++;
                break;
            }
        default:
            break;
        }
        if (pointCount>1)
        {
            *error = 1;
            break;
        }       
    }
}
 
void errorCorrection(char line[],int *error)
{
    int iCounter = 0;
 
    if ((line == ".")||(line == ","))
    {
        *error = 1;
    }
 
    if ((line[0] == '*')||(line[0] == '/'))
    {
        *error = 1;
    }
 
    while (line[iCounter] != '\0')
    {
        iCounter++;     
    }
    iCounter--;
 
    if ((line[iCounter] == '/')||(line[iCounter] == '*')||(line[iCounter] == '+')||(line[iCounter] == '-'))
    {
        *error = 1;
    }
    
}
 
/*Обработка ошибок. Что-то дописано, что взято из старого*/
int processingOfInputErrors(char *inputLine)
{
    int iCounter = 0,error = 0, answer = 1;
    char pernor = 'y';
 
    wasteSymbolDelete(inputLine,&error);
 
    if (error)
    {
        pernor = 't';
        printf("The program has made changes.\n%s\nDo you accept it? y\\n\n",inputLine);
        
        while ((pernor != 'y')&&(pernor != 'n') )
        {
            pernor = getch();
            if((pernor != 'y')&&(pernor != 'n'))
                printf("It is unclear, please re-enter.\n");
        }
    }
 
    if (pernor == 'y')
    {
        error = 0;
 
        singlePoint(inputLine,&error);
        errorCorrection(inputLine,&error);
        bracketsCount(inputLine,&error);
        inputSequence(inputLine,&error);
        onlyOnePoint(inputLine,&error);
        if (error)
            answer = 0;
    }
    else
    {
        answer = 0;
    }
    
    return answer;
}
 
/*удаление элементов из массива типа double*/
void doubleShift(double **mass, int startNumber, int numberOfShifts, int *numericSize)
{
    while ( startNumber+numberOfShifts <= *numericSize)
    {
        (*mass)[startNumber] = (*mass)[startNumber+numberOfShifts];
        (*mass)[startNumber+numberOfShifts] = 0;
        startNumber++;
    }
    (*numericSize)--;
}
 
/*Функция, возвращающая приоритет операции. в планах добавить новые операции (Sin, Cos, Log, скобки... Что еще в голову придет)*/
int discoverPriority(char symbol)
{
    int answer = 0;
    
    switch (symbol)
    {
        case '+':
        case '-':
            {
                answer = 1;
                break;
            }
        case '*':
        case '/':
            {
                answer = 2;
                break;
            }
        case '(':
            {
                answer = 0;
                break;
            }
        case 'S':
        case 'C':
        case 'L':
            {
                answer = 3;
                break;
            }
        default:
            {
                answer = -1;
            }
        break;
    }
    return answer;
}
 
/*Выталкивание операций из стека в ОПЗ*/
void stackShift(char **stackLine,char **outputLine, char symbol,int *stackCount, int *jCount)
{
    while ((discoverPriority(symbol)<=discoverPriority((*stackLine)[(*stackCount)-1]))&&(stackCount>0))
    {
        if ((*outputLine)[(*jCount)-1]!='?')
        {
            *outputLine = (char*) realloc(*outputLine, sizeof(char)*((*jCount)+1));
            (*outputLine)[(*jCount)++] ='?';        
        }
        
        *outputLine = (char*) realloc(*outputLine, sizeof(char)*((*jCount)+2));
        (*outputLine)[(*jCount)++] = (*stackLine)[--(*stackCount)];
        (*outputLine)[(*jCount)++] ='?';
    }
    *stackLine = (char*) realloc(*stackLine,sizeof(char)*((*stackCount)+1));
    (*stackLine)[*stackCount]=symbol;
}
 
/*Функция позволяет применять унарный минус, ну унарный плюс тоже.*/
void negation(char **inputLine,int *minus)
{
    int iCounter = 0, jCounter = 0;
    char pernor;
    while ((*inputLine)[jCounter] != '\0')
    {
        iCounter = 0;
        pernor = (*inputLine)[jCounter];
        if (((((*inputLine)[0] == '-'))||(((*inputLine)[jCounter] == '-')&& ((!isdigit((*inputLine)[jCounter-1]))&&((*inputLine)[jCounter-1] != ')')) ))
            ||
            ((((*inputLine)[0] == '+'))||(((*inputLine)[jCounter] == '+')&& ((!isdigit((*inputLine)[jCounter-1]))&&((*inputLine)[jCounter-1] != ')')) )))
        {
            
            while ((*inputLine)[iCounter] != '\0')
            {
                iCounter++;
            }
            *inputLine = (char*) realloc(*inputLine,iCounter+1);
        
            while (iCounter != jCounter)
            {
                (*inputLine)[iCounter+1] = (*inputLine)[iCounter];
                iCounter--;
            }
            (*inputLine)[iCounter+1] = pernor;
            (*inputLine)[iCounter] = '0';
            *minus = 1;
        }
 
        jCounter++;
 
    }
}
 
/*Формирование ОПЗ*/
void makeRPN(char **inputLine, char **outputLine, char **stackLine, int *countMath)
{
    int memory=0, iCount = 0, jCount = 0, stackCount = 0;
    while ((*inputLine)[iCount] != '\0')
    {
        switch ((*inputLine)[iCount])
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
        case '.':
        case ',':
            {
                if (!jCount||((((iCount-1)==memory)
                   &&
                   (isdigit((*outputLine)[jCount-1]) || ((*outputLine)[jCount-1]=='.') || ((*outputLine)[jCount-1]==','))))
                   )
                {
                    *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
                    (*outputLine)[jCount++] = (*inputLine)[iCount];
                    memory = iCount;
                }
                else
                {
                    if ((((*outputLine)[jCount-1])!='?')&&(jCount != 0))
                    {
                        *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
                        (*outputLine)[jCount++] = '?';
                    }
                    memory = iCount;
                    *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
                    (*outputLine)[jCount++] = (*inputLine)[iCount];
                }
            }
 
            break;
        
        case '-':
        case '+':
        case '*':
        case '/':
        case 'S':
        case 'C':
        case 'L':
            {
                stackShift(&(*stackLine),&(*outputLine),(*inputLine)[iCount],&stackCount,&jCount);
                *countMath++;
 
                stackCount++;
                break;
            }
        case '(':
            {
                *stackLine = (char*) realloc(*stackLine,sizeof(char)*(stackCount+1));
                (*stackLine)[stackCount++] = '('; /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
                break;
            }
        case ')':
            {
                while ((*stackLine)[stackCount-1] != '(')
                {
                    if ((*outputLine)[jCount-1] != '?')
                    {
                        (*outputLine) = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
                        (*outputLine)[jCount++] = '?';
                    }   
                    *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+2));
                    (*outputLine)[jCount++] = (*stackLine)[--stackCount];
                    (*outputLine)[jCount++] = '?';
                    (*stackLine)[stackCount] = '\0';
                }
                
                if ((*outputLine)[jCount-1] != '?')/*!!!!!!!!!!!!!!!!!!!!!!!!!*/
                    {
                        (*outputLine) = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
                        (*outputLine)[jCount++] = '?';
                    }   
 
                shift(*stackLine,stackCount-1,1);
                --stackCount;
                jCount--;
            }       
        }
        iCount++;
    }
 
 
 
    *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));    
    (*outputLine)[jCount++] = '?';/*? используется как разделитель, здесь добавляется в конец строки*/
    
    
 
    while (stackCount>0)/*Вывод остатка стека в ОПЗ*/
    {
        *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+2));/**/
        (*outputLine)[jCount++] = (*stackLine)[--stackCount];
        (*outputLine)[jCount++] = '?';
    }
    *outputLine = (char*) realloc(*outputLine, sizeof(char)*(jCount+1));
    (*outputLine)[jCount++] = '\0';
}/**/
 
/*Создание массива чисел*/
void conversionPRN(double **numeric,char ** outputLine, int *jCount)
{
    double  ten = 1,degreeCount = 1;
    int  iCount = 0;
    *jCount = 0;
 
    while ((*outputLine)[iCount] != '\0')
    {       
        switch ((*outputLine)[iCount])
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                {                   
                    if (ten)
                    {
                         (*numeric)[*jCount] = (*numeric)[*jCount]*10 + (double)((*outputLine)[iCount++]-'0');
                    }
                    else
                    {
                        (*numeric)[*jCount] = (*numeric)[*jCount] + (double)((*outputLine)[iCount++]-'0')*degreeCount;
                        degreeCount *= 0.1;
                    }
                    
                    if ((*outputLine)[iCount] == '?')
                    {
                        ten = 1;
                        *numeric = (double*) realloc(*numeric,sizeof(double)*((*jCount)+2));
                        (*jCount)++;
                        (*numeric)[*jCount] = 0;
                        degreeCount = 1;
                    }
                    break;
                }
            case '.':
            case ',':
                {
                    if (ten)
                    {
                        degreeCount *= 0.1;
                    }
                    ten = 0;
                }
            default:
            {
                iCount++;
                break;
            }
            break;
        }
    }
}
 
/*Функция вырезает числа из outputLine*/
void numeralCut(char **outputLine, int *error)
{
    int iCount = 0, jCount = 0,stackCount = 0;
    while ((*outputLine)[iCount] != '\0')
    {
        if (isdigit((*outputLine)[iCount])||((*outputLine)[iCount] == '.')||((*outputLine)[iCount] == ','))
        {
            while ((*outputLine)[++jCount] != '?')
            {
                stackCount++;
            }       
            shift(*outputLine,iCount,stackCount+1);
            jCount-=stackCount;
            stackCount = 0;
        }
        else
        {
            jCount++;
        }
        
        iCount++;
    }
}
 
void solutionPRN(char **outputLine,double **numeric, int *error,int *numericSize)
{   
    int jCount = 0,divisionByZero = 0;
    char pernor = 0;
    while (((*outputLine)[1] != '\0')&&(!divisionByZero))
    {
        jCount = 0;
        pernor = (*outputLine)[0];
 
        while (((pernor != '+')&&(pernor != '-')&&(pernor != '*')&&(pernor != '/')))
        {
            jCount++;
            pernor = (*outputLine)[jCount];
        }
 
        switch (pernor)
        {
        case '-':
            {
                (*numeric)[jCount-2] -= (*numeric)[jCount-1];
                break;
            }
        case '+':
            {
                (*numeric)[jCount-2] += (*numeric)[jCount-1];
                break;
            }
        case '*':
            {
                (*numeric)[jCount-2] *= (*numeric)[jCount-1];
                break;
            }
        case '/':
            {
                if (!(*numeric)[jCount-1])
                {
                    divisionByZero = 1;
                    break;
                }
                (*numeric)[jCount-2] /= (*numeric)[jCount-1];
                break;
            }
            break;
        }
        if (divisionByZero)
        {
            break;
        }
        doubleShift(&(*numeric), jCount-1,1,numericSize);
        shift(*outputLine,jCount-1,3);
    }
 
    if (divisionByZero)
    {
        *error = 2;
    }
    else
    {
        printf("Answer = %.4lf\n",(*numeric)[0]);
    }   
}
 
/*Все решение скомпановоно в одной функции*/
void decisionMath(char *inputLine, int *countError)
{   
    char  *outputLine, *stackLine;
    double *numeric;
    int countMath = 0, stackCount = 0, error = 0, numericSize = 0, minus = 0;
    numeric = (double*) malloc(sizeof(double)*1);
    outputLine = (char*) malloc(sizeof(char)*1);
    stackLine = (char*) malloc(sizeof(char)*1);
    numeric[0] = 0;
 
    negation(&inputLine,&minus);
    makeRPN(&inputLine,&outputLine,&stackLine,&countMath);
    conversionPRN(&numeric,&outputLine,&numericSize);
    numeralCut(&outputLine,countError);
 
    if (!(*countError))
    {
 
        solutionPRN(&outputLine,&numeric,&error,&numericSize);
    }
 
    if (error)
    {
        printf("Division by zero\n");
    }
    if (!minus)
    {
        free(inputLine);
    }   
    free(numeric);
    free(outputLine);
    
    if (countMath)
    {
        free(stackLine);
    }
}
 
 /*Вызывается при ошибке ввода*/
void inputError(char *repetition)
 {
    printf("Input error.\nWon't you try again? y\\n\n");
    *repetition = 't';
    while ((*repetition != 'y')&&(*repetition != 'n'))
    {
        if (((*repetition = getch())!= 'y')&&(*repetition != 'n'))
        {
            printf("It is unclear, please re-enter.\n");
        }
    }
    if (*repetition == 'y')
    {
        *repetition = 't';
    }
 
 }
 
 /*Спрашивает у пользователя, хочет ли он повторить итерацию*/
void programRepetition(char *repetition)
{
    printf("Won't you try again? y\\n\n");
    *repetition = 't';
    while ((*repetition != 'y')&&(*repetition != 'n'))
    {
        if (((*repetition = getch())!= 'y')&&(*repetition != 'n'))
        {
            printf("It is unclear, please re-enter.\n");
        }
    }
 }
 
void main()
{
    char repetition = 'y';
    int countError = 0;
 
    while ((repetition == 'y')||(repetition == 't'))
    {
        
        char *inputLine;
        repetition = 'y';
        inputLine = (char *) malloc(sizeof(char)*0);
        printf("Enter an expression\n");
        input(&inputLine);/*Ввод выражения*/
 
        if (processingOfInputErrors(inputLine))
        {
            decisionMath(inputLine,&countError);
            
            if (countError)
            {
                inputError(&repetition);
            }
        }
        else
        {
            inputError(&repetition);
        }
 
        if (repetition == 'y')
        {
            programRepetition(&repetition);
        }
            
    }
}