示例#1
0
        /// <summary>
        /// Принять сообщение с сервера
        /// </summary>
        void acceptMessageFromServer()
        {
            IFormatter    formatter = new BinaryFormatter();
            NetworkStream stream    = currentClient.GetStream();

            // Клиент находится в сети
            online = true;
            while (online)
            {
                try
                {
                    string msg = (string)formatter.Deserialize(stream);
                    this.BeginInvoke((MethodInvoker) delegate()
                    {
                        LoggerEvs.writeLog(msg);
                    });
                }
                catch (Exception ex)
                {
                    LoggerEvs.writeLog("Соединение с сервером разорвано.");
                    // Клиент больше не в сети
                    online = false;
                }
            }
        }
示例#2
0
 private void button1_Click(object sender, EventArgs e)
 {
     LoggerEvs.writeLog("Заполнение таблицы данными ряда...");
     fillTable();
     LoggerEvs.writeLog("Расчет математических характеристик...");
     calculateTableCharacteristics();
 }
示例#3
0
        private void showGraphicsButton_Click(object sender, EventArgs e)
        {
            switch (cbGraphKind.SelectedIndex)
            {
            case 0:
            {
                if (variationSeries != null)
                {
                    DisplayForm.DisplayStatFreq(variationSeries.SeriesTable);
                    LoggerEvs.writeLog("Построение полигона...");
                }
                break;
            }

            case 1:
            {
                if (intervalSeries != null)
                {
                    DisplayForm.DisplayIntervalFreq(intervalSeries.SeriesTable);
                    LoggerEvs.writeLog("Построение гистограммы...");
                }
                break;
            }

            case 2:
            {
                if (intervalSeries != null)
                {
                    EmpiricFunction.ShowEmpiricFunction(relativeSeries.SeriesTable);
                    LoggerEvs.writeLog("Построение функции распределения...");
                }
                break;
            }
            }
        }
示例#4
0
        public static double findMinimum(Interval searchInterval, double eps, int funcNumber)
        {
            bool   searchEnd = false;               // Конец поиска
            double x_min;                           // Значение x, при котором функция будет принимать минимальное значение

            double[] x_values = new double[4];      // Набор значений x
            double   x_answer;                      // Найденный ответ

            // Начало расчетов по методу Пауэлла
            LoggerEvs.writeLog("Powell's method has been started!");

            // Шаг первый
            x_values[0] = searchInterval.LeftEdge;
            x_values[1] = 0.5 * (searchInterval.LeftEdge + searchInterval.RightEdge);
            x_values[2] = searchInterval.RightEdge;
            LoggerEvs.writeLog(string.Format("Step 1: (x1, x2, x3) = ({0:f4}, {1:f4}, {2:f4}).", x_values[0], x_values[1], x_values[2]));

            for (int iter = 0; !searchEnd; iter++)
            {
                // Шаг второй
                x_min = findMinimum(x_values[0], x_values[1], x_values[2], funcNumber);
                LoggerEvs.writeLog(string.Format("Step 2: x_min value, when function has minimum value: {0:f4}.", x_min));

                // Шаг третий
                x_values[3] = findXFour(x_values[0], x_values[1], x_values[2], funcNumber);
                LoggerEvs.writeLog(string.Format("Step 3: count x4; x4 = {0:f4}.", x_values[3]));

                // Шаг четвертый
                if (Math.Abs(x_values[3] - x_min) <= eps)
                {
                    LoggerEvs.writeLog(string.Format("Step 4: |x4 - x_min| <= eps, |{0:f4} - {1:f4}| <= {2:f4} go to step 7!", x_values[3], x_min, eps));
                    // Перейти на шаг седьмой, поиск окончен
                    searchEnd = true;
                }
                else
                {
                    // Шаг пятый
                    LoggerEvs.writeLog("Step 5: Sorting x values: x1 < x2 < x3 < x4");
                    sort(ref x_values);

                    // Шаг шестой
                    double[] funcValues = new double[4];
                    // Вычислить значения функций от каждого аргумента
                    for (int i = 0; i < 4; i++)
                    {
                        funcValues[i] = countFunctionValue(funcNumber, x_values[i]);
                    }
                    // Отсортировать аргументы, чтобы получить первые три, при которых значения функций будут наименьшими
                    LoggerEvs.writeLog("Step 6: Sorting x values, for get first 3 values with which function's values will be minimal...");
                    sortXValues(ref x_values, funcValues);
                }
            }
            // Шаг седьмой
            x_answer = x_values[3];
            LoggerEvs.writeLog(string.Format("Step 7: Answer is {0:f4}", x_values[3]));
            return(x_answer);
        }
示例#5
0
        static void Main(string[] args)
        {
            LoggerEvs.messageCame += testToConsole;

            for (int i = 0; i < 10; i++)
            {
                LoggerEvs.writeLog("Test note №" + i.ToString());
            }

            Console.ReadKey();
        }
示例#6
0
 private void открытьToolStripMenuItem_Click(object sender, EventArgs e)
 {   // Открыть файл
     LoggerEvs.writeLog("Открытие входной выборки...");
     if (openDataInputFile())
     {
         LoggerEvs.writeLog("Входная выборка успешно открыта!");
     }
     else
     {
         LoggerEvs.writeLog("Ошибка при открытии входной выборки!");
     }
 }
示例#7
0
        public static Vector2 calculate(double x1, double x2, double h1, double h2, double eps)
        {
            LoggerEvs.writeLog("Hook Jeeves method started!");
            int     iterationsCount = 1;
            Vector2 b1 = new Vector2(x1, x2);
            Vector2 h  = new Vector2(h1, h2);

            LoggerEvs.writeLog("Input Data: (x1;x2) = (" + x1 + ";" + x2 + "). (h1;h2) = (" + h1 + ";" + h2 + ").");
step1:
            LoggerEvs.writeLog("Step 1.");
            Vector2 xk = b1.Clone();

            LoggerEvs.writeLog("Step 2.");
            Vector2 b2 = getBasisPoint(b1, h);

            LoggerEvs.writeLog("Results of step 1 and step 2. xk = " + xk + ", b2 = " + b2);
step3:
            LoggerEvs.writeLog("Iteration number " + iterationsCount);
            LoggerEvs.writeLog("Step 3.");
            xk = b1 + 2 * (b2 - b1);
            LoggerEvs.writeLog("xk = " + xk);
            iterationsCount++;
            LoggerEvs.writeLog("Step 4.");
            Vector2 x = getBasisPoint(xk, h);

            LoggerEvs.writeLog("New x = " + x);
            b1 = b2.Clone();
            if (Lab.task.formula(x) < Lab.task.formula(b1))
            {
                LoggerEvs.writeLog("Step 6.");
                LoggerEvs.writeLog("f(x)<f(b1), f(x) = " + Lab.task.formula(x) + ", f(b1)" + Lab.task.formula(b1));
                b2 = x.Clone();
                LoggerEvs.writeLog("b2 = " + b2);
                goto step3;
            }
            if (Lab.task.formula(x) > Lab.task.formula(b1))
            {
                LoggerEvs.writeLog("Step 7.");
                LoggerEvs.writeLog("f(x)>f(b1), f(x) = " + Lab.task.formula(x) + ", f(b1)" + Lab.task.formula(b1));
                goto step1;
            }
            LoggerEvs.writeLog("Step 8.");
            if (h.Length <= eps)
            {
                LoggerEvs.writeLog("Step 10.");
                LoggerEvs.writeLog("Stopping criterion... The result is " + b1);
                return(b1);
            }
            h /= 10;
            LoggerEvs.writeLog("Step 9. Now h = " + h);
            goto step1;
            throw new Exception("Что-то вообще не так");
        }
示例#8
0
        public Form1()
        {
            double eps = 0.01;

            LoggerEvs.messageCame += writeToLogWidget;
            InitializeComponent();
            LoggerEvs.writeLog("Application has been started!");
            rbDichotomy.Checked = true;
            rbFuncTest.Checked  = true;
            funcNumber          = 0;
            nudEpsilon.Value    = Convert.ToDecimal(eps);
        }
示例#9
0
        private void showGraphicsButton_Click(object sender, EventArgs e)
        {
            switch (cbGraphKind.SelectedIndex)
            {
            case 0:
            {
                if (groupedSeries != null)
                {
                    SortedDictionary <double, int> modifiedSeries = new SortedDictionary <double, int>();
                    double summ = groupedSeries.ElementsCount;
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        modifiedSeries.Add(pair.Key, (int)(pair.Value * summ));
                    }
                    DisplayForm.DisplayStatFreq(modifiedSeries);
                    LoggerEvs.writeLog("Построение полигона...");
                }
                break;
            }

            case 1:
            {
                if (intSeries != null)
                {
                    DisplayForm.DisplayIntervalFreq(intSeries.SeriesTable);
                    LoggerEvs.writeLog("Построение гистограммы...");
                }
                break;
            }

            case 2:
            {
                if (groupedSeries != null)
                {
                    SortedDictionary <double, double> modifiedSeries = new SortedDictionary <double, double>();
                    double summ = 0;
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        summ += pair.Value;
                    }
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        modifiedSeries.Add(pair.Key, pair.Value / summ);
                    }
                    EmpiricFunction.ShowEmpiricFunction(modifiedSeries);
                    LoggerEvs.writeLog("Построение функции распределения...");
                }
                break;
            }
            }
        }
        public static double findMinimum(Interval searchInterval, double eps, int funcNumber)
        {
            LoggerEvs.writeLog("Dichotomy method has been started!");
            double x_end = 0;                       // Найденное значение x
            double x_1, x_2;                        // Границы промежуточных отрезков
            bool   countStop = false;               // Остановка расчетов
            double delta = eps / 10;                // Константа "различимости"
            double f_x_1, f_x_2;

            LoggerEvs.writeLog("Counting: delta = eps / 10 = " + delta);
            for (int i = 0; !countStop; i++)
            {
                // Шаг первый
                x_1 = 0.5 * (searchInterval.LeftEdge + searchInterval.RightEdge) - delta;
                x_2 = 0.5 * (searchInterval.LeftEdge + searchInterval.RightEdge) + delta;
                LoggerEvs.writeLog(string.Format("Step 1: counting x_1 = {0:f4}, x_2 = {1:f4}", x_1, x_2));
                // Шаг второй (вычисление) и третий (сравнение)
                f_x_1 = countFunctionValue(funcNumber, x_1);
                f_x_2 = countFunctionValue(funcNumber, x_2);
                if (f_x_1 <= f_x_2)
                {
                    searchInterval.RightEdge = x_2;
                    LoggerEvs.writeLog(string.Format("Step 3: f({0:f4}) = {1:f4} <= f({2:f4}) = {3:f4}; b = x_2 = {4:f4}.", x_1, f_x_1, x_2, f_x_2, x_2));
                }
                else
                {
                    searchInterval.LeftEdge = x_1;
                    LoggerEvs.writeLog(string.Format("Step 3: f({0:f4}) = {1:f4} > f({2:f4}) = {3:f4}; a = x_1 = {4:f4}.", x_1, f_x_1, x_2, f_x_2, x_1));
                }
                // Шаг четвертый
                double diff = (searchInterval.RightEdge - searchInterval.LeftEdge) / 2;
                if (diff < eps)
                {
                    countStop = true;
                    LoggerEvs.writeLog(string.Format("Step 4: (b-a)/2 = {0:f4} < eps = {1:f4}; STOP SEARCHING!", diff, eps));
                }
                LoggerEvs.writeLog("Iter " + i + ": Answer is in the range: [" + searchInterval.LeftEdge.ToString("f4") + "; " + searchInterval.RightEdge.ToString("f4") + "]");
            }
            // Шаг пятый
            x_end = (searchInterval.LeftEdge + searchInterval.RightEdge) / 2;
            // Вывод результата
            LoggerEvs.writeLog("Step 5: x_end = (a+b)/2; Minimum x* is: " + x_end.ToString("f4"));
            return(x_end);
        }
示例#11
0
 private void btnEnterToChat_Click(object sender, EventArgs e)
 {
     if (checkNickname())
     {
         try
         {
             connectToServer();
             setupWidgsAfterConnection();
             // Запустить прием сообщений
             thMsgAccepting = new Thread(delegate() { acceptMessageFromServer(); });
             thMsgAccepting.Start();
         }
         catch (Exception ex)
         {
             String error = ex.ToString();//"Ошибка при подключении к серверу";
             LoggerEvs.writeLog(error);
             MessageBox.Show(error);
         }
     }
 }
示例#12
0
        // Проверить входные данные
        private bool correctDatainput()
        {
            bool correctData = true;

            if (nudH.Value <= 0)
            {
                LoggerEvs.writeLog("Step h must be > 0");
                correctData = false;
            }
            else if (funcNumber == -1)
            {
                LoggerEvs.writeLog("Choose the function for counting.");
                correctData = false;
            }
            else if (nudEpsilon.Value <= 0 || nudEpsilon.Value >= 1)
            {
                LoggerEvs.writeLog("Epsilon must be > 0 and < 1!");
                correctData = false;
            }
            return(correctData);
        }
示例#13
0
        /// <summary>
        /// Обработка запросов
        /// </summary>
        /// <param name="clientId"></param>
        static void requestsProcessing(int clientId)
        {
            IFormatter formatter = new BinaryFormatter();
            // Поток клиента
            NetworkStream currentClientStream = clients[clientId].MyTcpClient.GetStream();

            while (true)
            {
                // Получить запрос
                object request = formatter.Deserialize(currentClientStream);
                switch ((int)request)
                {
                // Клиент прислал сообщение для других пользователей
                case (int)Requests.NewMessage:
                    // Принять сообщение
                    UsualMessage message  = acceptClientMessage(clientId);
                    string       msgToLog = message.Sender + ": " + message.Message;
                    LoggerEvs.writeLog(msgToLog);
                    // Разослать сообщение всем клиентам
                    sendMessageToClients(msgToLog);
                    break;

                // Клиент прислал запрос на закрытие соединения
                case (int)Requests.CloseConnection:
                    lock (locker)
                    {
                        // Закрыть соединение с клиентом
                        clients[clientId].MyTcpClient.Close();
                        // Удалить клиента из коллекции
                        clients.Remove(clientId);
                        // Оповестить клиентов об отключение данного
                        string closeConnectionMessage = "Client " + clientId + " has just been disconnected.";
                        sendMessageToClients(closeConnectionMessage);
                        LoggerEvs.writeLog(closeConnectionMessage);
                        // Завершать выполнение потока
                        return;
                    }
                }
            }
        }
示例#14
0
        static void Main(string[] args)
        {
            LoggerEvs.messageCame += logToConsole;
            /////////////////////////////////
            // Получить настройки сервера
            ServerProperties serverProps = new ServerProperties();

            serverProps.ReadXML();
            String propsMsg = String.Format("Настройки сервера: ServerName = {0}; IP = {1}; Port = {2};", serverProps.Fields.ServerName, IPAddress.Any.ToString(), serverProps.Fields.Port);

            LoggerEvs.writeLog(propsMsg);
            Console.Title = serverProps.Fields.ServerName;
            // Создать tcp-слушатель
            TcpListener myTcpListener = new TcpListener(IPAddress.Any, serverProps.Fields.Port);

            // Запустить слушатель
            myTcpListener.Start();
            // Текущий подключенный клиент
            TcpClient client;
            // Текущий поток клиента
            Thread clientTh;

            while (true)
            {
                // Принять новое подключение
                client = myTcpListener.AcceptTcpClient();
                LoggerEvs.writeLog("New client connected.");
                lock (locker)
                {
                    int id = globalClientsId;
                    clientTh = new Thread(delegate() { requestsProcessing(id); });
                    Client newClient = new Client(clientTh, client, globalClientsId);
                    // Добавить клиента в коллекцию
                    clients.Add(id, newClient);
                    // Создать новый поток
                    clients[id].Thread.Start();
                    globalClientsId++;
                }
            }
        }
示例#15
0
 private void disconnectFromServer()
 {
     try
     {
         if (currentClient.Connected)
         {
             IFormatter    formatter = new BinaryFormatter();
             NetworkStream stream    = currentClient.GetStream();
             // Клиент отсоединился
             online = false;
             // Отправить серверу запрос на отключение
             formatter.Serialize(stream, Requests.CloseConnection);
             // Отправить серверу никнейм отключившегося пользователя
             formatter.Serialize(stream, tbNickname.Text);
             currentClient.Close();
         }
     }
     catch (Exception ex)
     {
         LoggerEvs.writeLog("Проблемы с отключением от сервера.");
     }
 }
示例#16
0
        /// <summary>
        /// Разослать сообщения клиентам
        /// </summary>
        /// <param name="message">Сообщение</param>
        static void sendMessageToClients(string message)
        {
            IFormatter    formatter = new BinaryFormatter();
            NetworkStream clientStream;

            lock (locker)
            {
                foreach (var client in clients)
                {
                    try
                    {
                        // Получить поток клиента
                        clientStream = client.Value.MyTcpClient.GetStream();
                        // Отослать клиенту сообщение
                        formatter.Serialize(clientStream, message);
                    }
                    catch (Exception ex)
                    {
                        LoggerEvs.writeLog(ex.ToString());
                    }
                }
            }
        }
示例#17
0
 private void printTable()
 {
     clearTables();
     if (seriesType.SelectedIndex == 0)
     {
         printVariationSeries();
         LoggerEvs.writeLog("Построение статистического ряда частот...");
     }
     else if (seriesType.SelectedIndex == 1)
     {
         printRelativeSeries();
         LoggerEvs.writeLog("Построение статистического ряда относительных частот...");
     }
     else if (seriesType.SelectedIndex == 2)
     {
         printIntervalSeries();
         LoggerEvs.writeLog("Построение интервального статистического ряда частот...");
     }
     else if (seriesType.SelectedIndex == 3)
     {
         printGroupedRelativeSeries();
         LoggerEvs.writeLog("Построение группированного ряда частот...");
     }
 }
示例#18
0
 private void fillTable()
 {
     if (SourceValues.valuesTable != null)
     {
         variationSeries       = VariationSeries.calculateSerires();
         relativeSeries        = variationSeries.getRelativeSeries();
         intervalSeries        = variationSeries.getIntervalVariationSeries((int)intervalsCountUpDown.Value);
         groupedRelativeSeries = variationSeries.getGroupedRelativeArequenceSeries((int)intervalsCountUpDown.Value);
         calculated            = true;
         printTable();
     }
     else
     {
         string errMsg = "Необходимо загрузить выборку из файла. Выберите файл с выборкой.";
         MessageBox.Show(errMsg, "Внимание");
         LoggerEvs.writeLog(errMsg);
         LoggerEvs.writeLog("Открытие входной выборки...");
         if (openDataInputFile())
         {
             LoggerEvs.writeLog("Входная выборка успешно открыта!");
             fillTable();
         }
     }
 }
示例#19
0
        public static Interval countInterval(int funcNumber, double h, double x_0)
        {
            LoggerEvs.writeLog("DSK method started!");
            Interval      answer         = new Interval(0, 1); // Убрать инициализацию
            int           functionNumber = 0;                  // Номер функции
            double        f_x_0;                               // Значение функции в точке x_0
            double        f_x_0_h;                             // Значение функции в точке x_0 + h
            bool          searchEnd = false;                   // Конец поиска
            List <double> x_values  = new List <double>();     // Коллекция значений x_0

            x_values.Add(x_0);
            // Шаг 1
            f_x_0   = countFunctionValue(funcNumber, x_0);
            f_x_0_h = countFunctionValue(funcNumber, x_0 + h);
            int k = 0;

            LoggerEvs.writeLog("Step 1: f(x_0)=" + f_x_0.ToString("f4") + ", f(x_0 + h)=" + f_x_0_h.ToString("f4") + "; k=0;");
            // Шаг 2
            if (f_x_0 > f_x_0_h)
            {
                answer.LeftEdge = x_0;
                double x_tmp = x_0 + h;
                x_values.Add(x_tmp);
                k = 2;
                LoggerEvs.writeLog("Step 2: a=" + x_0.ToString("f4") + ", x_1=" + x_tmp.ToString("f4") + ", k=2; Go to step 4!");
                // Перейти на шаг 4
            }
            else
            {
                // Шаг 3
                if (countFunctionValue(funcNumber, x_0 - h) >= f_x_0)
                {
                    answer.LeftEdge  = x_0 - h;
                    answer.RightEdge = x_0 + h;
                    LoggerEvs.writeLog("Step 3: a=" + answer.LeftEdge.ToString("f4") + ", b=" + answer.RightEdge.ToString("f4") + "; Go to step 6!");
                    // Перейти на шаг 6
                    searchEnd = true;
                }
                else
                {
                    answer.RightEdge = x_0;
                    x_values.Insert(1, x_0 - h);
                    h = -h;
                    k = 2;
                    LoggerEvs.writeLog("Step 3: b=" + x_0.ToString("f4") + ", x_1=" + (x_0 - h).ToString("f4") + ", h=" + h.ToString("f4") + ", k=2.");
                }
            }
            while (!searchEnd)
            {
                // Шаг 4
                x_values.Insert(k, 0);
                x_values[k] = x_0 + Math.Pow(2, k - 1) * h;
                LoggerEvs.writeLog("Step 4: x_k=" + x_values[k].ToString("f4"));
                // Шаг 5
                if (countFunctionValue(funcNumber, x_values[k - 1]) <= countFunctionValue(funcNumber, x_values[k]))
                {
                    if (h > 0)
                    {
                        answer.RightEdge = x_values[k];
                        LoggerEvs.writeLog("Step 5: h > 0; b=x_k=" + answer.RightEdge.ToString("f4"));
                    }
                    else
                    {
                        answer.LeftEdge = x_values[k];
                        LoggerEvs.writeLog("Step 5: h < 0; a=x_k" + answer.LeftEdge.ToString("f4"));
                    }
                    searchEnd = true;
                }
                else
                {
                    if (h > 0)
                    {
                        answer.LeftEdge = x_values[k - 1];
                        LoggerEvs.writeLog("Step 5: h > 0; a=x_(k-1)=" + answer.LeftEdge.ToString("f4"));
                    }
                    else
                    {
                        answer.RightEdge = x_values[k - 1];
                        LoggerEvs.writeLog("Step 5: h > 0; b=x_(k-1)=" + answer.RightEdge.ToString("f4"));
                    }

                    // Перейти на шаг 4
                    k++;
                    LoggerEvs.writeLog("k = k + 1 = " + k + "; Go to step 4!");
                }
            }
            // Шаг 6
            LoggerEvs.writeLog("Step 6: Interval is: [" + answer.LeftEdge.ToString("f4") + " ; " + answer.RightEdge.ToString("f4") + "]");
            return(answer);
        }
        public static Vector2 findMinimum(Vector2 x_0, double alpha, double beta, int t0, int M, double R, int N)
        {
            Vector2 answer   = new Vector2();
            double  n        = 1;
            bool    wasFound = false;

            Vector2[] yVectors      = new Vector2[N + 1];
            Vector2[] xVectors      = new Vector2[N + 1];
            Vector2[] rndKsiVectors = new Vector2[N + 1];
            double[]  tValues       = new double[N + 1];
            Vector2[] zVectors      = new Vector2[N + 1];
            LoggerEvs.writeLog("Adaptive searching method started!");
            ////////////////////////////////////////////////
            // Шаг первый
            // Задать начальные условия
            string startConditions = string.Format("- Alpha\t = {0:f4}\r\n- Beta\t = {1:f4}\r\n- t0\t = {2}\r\n- M\t = {3}\r\n- R\t = {4:f5}\r\n- N\t = {5}\r\n- X0\t = {6}.", alpha, beta, t0, M, R, N, x_0.ToString());

            LoggerEvs.writeLog("Step 1: Setting start conditions (values)...\r\n" + startConditions);
            tValues[0] = t0;
            // Задать начальную точку
            xVectors[0] = x_0;
            // Положить
            int k = 0;
            int j = 1;

            while (!wasFound)
            {
                ////////////////////////////////////////////////
                // Шаг второй
                // Получить случайный вектор
                rndKsiVectors[j] = Vector2.getRandomVectorKsi();
                LoggerEvs.writeLog(string.Format("Step 2: Getting random ksi-vector: {0}.", rndKsiVectors[j].ToString()));

                ////////////////////////////////////////////////
                // Шаг третий
                // Вычислить y_j
                yVectors[j] = xVectors[k] + tValues[k] * (rndKsiVectors[j] / rndKsiVectors[j].getEuclidNorm());
                LoggerEvs.writeLog(string.Format("Step 3: Counting y_j = {0}.", yVectors[j].ToString()));
                ////////////////////////////////////////////////
                // Шаг четвертый
                double f_y_j = Lab.task.formula(yVectors[j]);
                double f_x_k = Lab.task.formula(xVectors[k]);
                LoggerEvs.writeLog(string.Format("Step 4: f_y_j = {0:f4}, f_x_k = {1:f4}", f_y_j, f_x_k));
                // а)
                if (f_y_j < f_x_k)
                {
                    zVectors[j] = xVectors[k] + alpha * (yVectors[j] - xVectors[k]);
                    LoggerEvs.writeLog(string.Format("f_y_j < f_x_k: {0:f4} < {1:f4}; z_j = {2}.", f_y_j, f_x_k, zVectors[j].ToString()));
                    // Определить, является ли текущее направление y_j - x_k удачным:
                    double f_z_j = Lab.task.formula(zVectors[j]);
                    if (f_z_j < f_x_k)
                    {
                        // Направление поиска удачное
                        xVectors[k + 1] = zVectors[j];
                        tValues[k + 1]  = alpha * tValues[k];
                        k += 1;
                        LoggerEvs.writeLog(string.Format("f_z_j < f_x_k: {0:f4} < {1:f4}; x_k+1 = {2}, t_k = {3:f4}, k = k + 1 = {4}.", f_z_j, f_x_k, zVectors[j].ToString(), tValues[k], k));
                        // Проверить условие окончания поиска
                        if (k < N)
                        {
                            j = 1;
                            // Перейти к шагу 2
                            LoggerEvs.writeLog(string.Format("k < N: {0} < {1}; j = 1; Go to step 2!", k, N));
                        }
                        else if (k == N)
                        {
                            // Поиск завершен
                            answer   = xVectors[k];
                            wasFound = true;
                            LoggerEvs.writeLog(string.Format("k == N: {0} == {1}; Stop searching! Answer x* is {2}", k, N, answer.ToString()));
                        }
                    }
                    else if (f_z_j >= f_x_k)
                    {
                        // Направление поиска неудачное, перейти к шагу 5
                        LoggerEvs.writeLog(string.Format("The searching way is unlucky: f_z_j >= f_x_k: {0:f4} >= {1:f4}. Go to step 5!", f_z_j, f_x_k));
                    }
                }
                // б)
                else if (f_y_j >= f_x_k)
                {
                    // Шаг недуачный перейти к шагу 5
                    LoggerEvs.writeLog(string.Format("The step is unlucky: f_y_j >= f_x_k: {0:f4} >= {1:f4} :go to step 5!", f_y_j, f_x_k));
                }

                ////////////////////////////////////////////////
                // Шаг пятый
                // Оценить число неудачных шагов из текущей точки
                // a)
                if (j < M)
                {
                    j += 1;
                    LoggerEvs.writeLog(string.Format("Step 5: j < M: {0} < {1}; j = j + 1 = {2}. Go to step 2!", j - 1, M, j));
                    // Перейти к шагу 2
                }
                // б)
                else if (j == M)
                {
                    // Проверить условия окончания
                    if (tValues[k] <= R)
                    {
                        // Процесс закончить:
                        answer   = xVectors[k];
                        wasFound = true;
                        // Рассчитать значение функции
                        LoggerEvs.writeLog(string.Format("Step 5: Stop searching! Answer x* is {0}, f(x*) = {1:f4}", answer.ToString(), Lab.task.formula(answer)));
                    }
                    else if (tValues[k] > R)
                    {
                        tValues[k] = beta * tValues[k];
                        j          = 1;
                        // Перейти к шагу 2
                        LoggerEvs.writeLog(string.Format("Step 5: t_k = beta * t_k = {0:f4}, j = {1}. Go to step 2!", tValues[k], j));
                    }
                }
            }
            return(answer);
        }
示例#21
0
        // Построение графиков
        #region ShowGraphics

        private void showGraphicsButton_Click(object sender, EventArgs e)
        {
            switch (cbGraphKind.SelectedIndex)
            {
            case 0:
            {
                if (groupedSeries != null)
                {
                    SortedDictionary <double, int> modifiedSeries = new SortedDictionary <double, int>();
                    double summ = groupedSeries.ElementsCount;
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        modifiedSeries.Add(pair.Key, (int)(pair.Value * summ));
                    }
                    DisplayForm.DisplayStatFreq(modifiedSeries);
                    LoggerEvs.writeLog("Построение полигона...");
                }
                break;
            }

            case 1:
            {
                if (intSeries != null)
                {
                    DisplayForm.DisplayIntervalFreq(intSeries.SeriesTable);
                    LoggerEvs.writeLog("Построение гистограммы...");
                }
                break;
            }

            case 2:
            {
                if (groupedSeries != null)
                {
                    SortedDictionary <double, double> modifiedSeries = new SortedDictionary <double, double>();
                    double summ = 0;
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        summ += pair.Value;
                    }
                    foreach (var pair in groupedSeries.SeriesTable)
                    {
                        modifiedSeries.Add(pair.Key, pair.Value / summ);
                    }
                    EmpiricFunction.ShowEmpiricFunction(modifiedSeries);
                    LoggerEvs.writeLog("Построение функции распределения...");
                }
                break;
            }

            case 3:
            {
                if (groupedSeries != null)
                {
                    CheckDistributionForm wnd = new CheckDistributionForm();
                    double sampleMeanSquare   = SeriesCharacteristics.calculateSampleMeanSquareNew(groupedSeries.SeriesTable);
                    double sampleMean         = SeriesCharacteristics.calculateSampleMean(groupedSeries.SeriesTable);
                    double dispersion         = SeriesCharacteristics.calculateDispersion(groupedSeries.SeriesTable);
                    wnd.draw_distribution(groupedSeries.SeriesTable, "Выборка", sampleMean, sampleMeanSquare, Color.FromArgb(255, 255, 0, 255));
                    wnd.drawNormalDistribution(dispersion, sampleMeanSquare, sampleMean);
                    wnd.Show();
                }
                break;
            }

            case 4:
            {
                if (groupedSeries != null)
                {
                    CheckDistributionForm wnd = new CheckDistributionForm();
                    double sampleMeanSquare   = SeriesCharacteristics.calculateSampleMeanSquareNew(groupedSeries.SeriesTable);
                    double sampleMean         = SeriesCharacteristics.calculateSampleMean(groupedSeries.SeriesTable);
                    double dispersion         = SeriesCharacteristics.calculateDispersion(groupedSeries.SeriesTable);
                    wnd.draw_distribution(groupedSeries.SeriesTable, "Выборка", sampleMean, sampleMeanSquare, Color.FromArgb(255, 255, 0, 255));
                    wnd.drawExpDistribution(dispersion, sampleMeanSquare, sampleMean);
                    wnd.Show();
                }
                break;
            }
            }
        }
示例#22
0
        /// <summary>
        /// Метод для открытия файла входных данных и их чтения
        /// </summary>
        /// <returns>Сведения о том, удалось ли открыть файл</returns>
        public bool openDataInputFile()
        {
            bool fileRead = false;                  // Файл прочитан

            // Имя файла по умолчанию
            ofdLoadDataInput.FileName = null;
            // Отбор текстовых документов txt
            ofdLoadDataInput.Filter = "Текстовые документы txt|*.txt";
            // Заголовок окна fileDialog
            ofdLoadDataInput.Title = "Выберите текстовый документ";
            // Запретить одновременный выбор нескольких файлов
            ofdLoadDataInput.Multiselect = false;

            try
            {
                // Загрузить входные данные
                string dataInput = null;
                if (ofdLoadDataInput.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    // Создать поток чтения из файла
                    using (StreamReader dataInputReader = new StreamReader(ofdLoadDataInput.FileName))
                    {
                        dataInput = dataInputReader.ReadToEnd();
                        dataInputReader.Close();
                    }

                    // Распарсить входные данные
                    // Сформировать единую строку даных без переносов
                    dataInput = dataInput.Replace(";\r\n", ";");

                    // Сформировать массив строк с входными данными вида 4|1|3;
                    string[] rows = dataInput.Split(';');
                    // Очистить коллекцию входных данных
                    // Для записи входных данных
                    int matrixSize = rows.Length - 1;
                    SourceValues.valuesTable = new double[matrixSize, matrixSize]; // Матрица коэффициентов (сюда будут записаны данные из файла)

                    // Получить цифровые данные

                    for (int i = 0; i < matrixSize; i++)
                    {
                        if (rows[i].Length > 0)
                        {
                            string[] nums = rows[i].Split('|');

                            // Заполнить матрицу числами
                            for (int j = 0; j < matrixSize; j++)
                            {
                                if (nums[j].Any(s => s == '.'))
                                {
                                    nums[j] = nums[j].Replace('.', ',');
                                }
                                SourceValues.valuesTable[i, j] = Convert.ToDouble(nums[j]);
                            }
                        }
                    }
                    fileRead = true;
                }
            }
            catch (Exception ex)
            {
                // Сообщение с текстом ошибки
                string errorMessage = ex.ToString() + "\n\nНе удалось обработать входные данные.";
                // Вывести сообщение об ошибке
                MessageBox.Show(errorMessage);
                LoggerEvs.writeLog(errorMessage);
            }
            if (fileRead)
            {
                statusLabel.Text = "Была загружена новая выборка";
            }
            // Вернуть данные о том, прочитан ли файл
            return(fileRead);
        }
示例#23
0
        public override void Execute()
        {
            IFormatter formatter = new BinaryFormatter();

            switch (_command)
            {
            case RequestTypes.EditPosition:
            {
                LoggerEvs.writeLog("Edit position");

                var posModel = (PositionModel)formatter.Deserialize(_stream);

                var pos = positionsRepo.Get(posModel.Id);

                pos.Name = posModel.Name;
                positionsRepo.Update(pos);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Position updated");
                break;
            }

            case RequestTypes.RemovePosition:
            {
                LoggerEvs.writeLog("Remove position");

                var posId = (int)formatter.Deserialize(_stream);

                var position = positionsRepo.Get(posId);
                positionsRepo.Delete(position);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Position removed");
                break;
            }

            case RequestTypes.CreatePosition:
            {
                LoggerEvs.writeLog("Creating position");

                var positionModel = (PositionModel)formatter.Deserialize(_stream);

                positionsRepo.Create(new Position
                    {
                        Name   = positionModel.Name,
                        Salary = 1
                    });

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Position created");
                break;
            }

            case RequestTypes.CreateDep:
            {
                LoggerEvs.writeLog("Create department");

                var depModel = (DepartmentModel)formatter.Deserialize(_stream);

                depsRepo.Create(new Department
                    {
                        EmployeeHeadId = -1,
                        Name           = depModel.Name,
                        Situation      = " "
                    });

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Department created");
                break;
            }

            case RequestTypes.EditDepartment:
            {
                LoggerEvs.writeLog("Edit department");

                var depModel = (DepartmentModel)formatter.Deserialize(_stream);

                var updates = new Department
                {
                    EmployeeHeadId = -1,
                    Id             = depModel.Id,
                    Name           = depModel.Name,
                    Situation      = ""
                };

                depsRepo.Update(updates);
                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Department updated");
                break;
            }

            case RequestTypes.RemoveDep:
            {
                LoggerEvs.writeLog("Remove department");

                var depId = (int)formatter.Deserialize(_stream);

                var dep = depsRepo.Get(depId);
                depsRepo.Delete(dep);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Department removed");
                break;
            }

            case RequestTypes.EditPayout:
            {
                LoggerEvs.writeLog("Update payout");

                var payoutEditModel = (EditPayoutModel)formatter.Deserialize(_stream);

                var payout = payoutsRepo.Get(payoutEditModel.PayoutId);

                payout.Sum = payoutEditModel.Sum;

                payoutsRepo.Update(payout);

                formatter.Serialize(_stream, new PayoutModel
                    {
                        Id  = payout.Id,
                        Sum = payout.Sum
                    });

                LoggerEvs.writeLog("Payout updated");
                break;
            }

            case RequestTypes.RemovePayout:
            {
                LoggerEvs.writeLog("Remove payout");

                var payoutId = (int)formatter.Deserialize(_stream);
                var payout   = payoutsRepo.Get(payoutId);
                payoutsRepo.Delete(payout);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Payout removed");
                break;
            }

            case RequestTypes.GetPayouts:
            {
                LoggerEvs.writeLog("Get payouts");

                var empId = (int)formatter.Deserialize(_stream);

                var payouts = payoutsRepo.GetAll()
                              .Where(x => x.EmployeeId == empId)
                              .Join(payoutTypesRepo.GetAll(), x => x.PayoutTypeId, y => y.Id, (x, y) => new PayoutModel
                    {
                        Id         = x.Id,
                        PayoutType = y.Name,
                        Sum        = x.Sum
                    })
                              .ToList();

                formatter.Serialize(_stream, payouts);

                LoggerEvs.writeLog("Payouts sent");
                break;
            }

            case RequestTypes.GetPayoutTypes:
            {
                LoggerEvs.writeLog("Get payout types");

                var payoutTypes = payoutTypesRepo.GetAll()
                                  .Select(x => new PayoutTypeModel
                    {
                        Id   = x.Id,
                        Name = x.Name
                    })
                                  .ToList();

                formatter.Serialize(_stream, ResponseTypes.Data);
                formatter.Serialize(_stream, payoutTypes);

                LoggerEvs.writeLog("Payout types sent");
                break;
            }

            case RequestTypes.CreatePayout:
            {
                LoggerEvs.writeLog("Assign payout");

                var assignPayout = (AssignPayoutModel)formatter.Deserialize(_stream);

                var payout = payoutsRepo.Create(new Payout()
                    {
                        EmployeeId   = assignPayout.EmployeeId,
                        PayoutTypeId = assignPayout.PayoutTypeId,
                        Sum          = assignPayout.Sum
                    });

                formatter.Serialize(_stream, ResponseTypes.Data);
                formatter.Serialize(_stream, payout.Id);

                LoggerEvs.writeLog("Payout assigned");
                break;
            }

            case RequestTypes.FireEmp:
            {
                LoggerEvs.writeLog("Fire emp");

                var empId = (int)formatter.Deserialize(_stream);

                var emp = empsRepo.Get(empId);
                empsRepo.Delete(emp);

                formatter.Serialize(_stream, ResponseTypes.Data);
                formatter.Serialize(_stream, empId);

                LoggerEvs.writeLog("Emp fired");
                break;
            }

            case RequestTypes.GetDepartments:
                LoggerEvs.writeLog("Get departments");

                var deps = depsRepo.GetAll()
                           .Select(x => new DepartmentModel
                {
                    Id   = x.Id,
                    Name = x.Name
                })
                           .ToList();

                formatter.Serialize(_stream, ResponseTypes.Data);
                formatter.Serialize(_stream, deps);

                LoggerEvs.writeLog("Departments sent");
                break;

            case RequestTypes.GetPositions:
                LoggerEvs.writeLog("Get positions");

                var positions = positionsRepo.GetAll()
                                .Select(x => new PositionModel
                {
                    Id   = x.Id,
                    Name = x.Name
                })
                                .ToList();

                formatter.Serialize(_stream, ResponseTypes.Data);
                formatter.Serialize(_stream, positions);

                LoggerEvs.writeLog("Positions sent");
                break;

            case RequestTypes.GetEmps:
                LoggerEvs.writeLog("Get emps request");
                var emps = empsRepo.GetAll()
                           .Join(positionsRepo.GetAll(), x => x.PositionId, y => y.Id, (x, y) => new
                {
                    Id           = x.Id,
                    FirstName    = x.FirstName,
                    LastName     = x.LastName,
                    MiddleName   = x.MiddleName,
                    Position     = y.Name,
                    DepartmentId = x.DepartmentId
                })
                           .Join(depsRepo.GetAll(), x => x.DepartmentId, y => y.Id, (x, y) => new EmployeeModel
                {
                    Department = y.Name,
                    Id         = x.Id,
                    FirstName  = x.FirstName,
                    LastName   = x.LastName,
                    MiddleName = x.MiddleName,
                    Position   = x.Position
                })
                           .ToList();

                formatter.Serialize(_stream, ResponseTypes.Data);

                formatter.Serialize(_stream, emps);
                LoggerEvs.writeLog("Emps sent");
                break;

            case RequestTypes.EditEmp:
            {
                LoggerEvs.writeLog("Edit emp request");
                var empFromRequuest = (EmployeeEditModel)formatter.Deserialize(_stream);

                try
                {
                    var position = positionsRepo.Get(empFromRequuest.PositionId);

                    var dep = depsRepo.Get(empFromRequuest.DepartmentId);

                    var emp = empsRepo.Get(empFromRequuest.Id);

                    emp.LastName     = empFromRequuest.LastName;
                    emp.MiddleName   = empFromRequuest.MiddleName;
                    emp.FirstName    = empFromRequuest.FirstName;
                    emp.DepartmentId = dep.Id;
                    emp.PositionId   = position.Id;

                    empsRepo.Update(emp);

                    formatter.Serialize(_stream, ResponseTypes.Data);

                    // Отправить обновленную информацию на клиент
                    formatter.Serialize(_stream, new EmployeeModel
                        {
                            Id         = emp.Id,
                            FirstName  = emp.FirstName,
                            LastName   = emp.LastName,
                            MiddleName = emp.LastName,
                            Department = dep.Name,
                            Position   = position.Name
                        });
                    LoggerEvs.writeLog("Emp updated, sending actual info");
                }
                catch (Exception ex)
                {
                    formatter.Serialize(_stream, ResponseTypes.Error);
                    formatter.Serialize(_stream, ex.Message);
                    Console.WriteLine(ex.Message);
                }
                break;
            }

            case RequestTypes.CreateEmp:
                LoggerEvs.writeLog("Create emp request");
                var newEmpModel = (EmployeeModel)formatter.Deserialize(_stream);

                try
                {
                    var position = positionsRepo.GetAll()
                                   .Where(x => x.Name == newEmpModel.Position)
                                   .FirstOrDefault();

                    var dept = depsRepo.GetAll()
                               .Where(x => x.Name == newEmpModel.Department)
                               .FirstOrDefault();

                    var emp = new Employee
                    {
                        FirstName    = newEmpModel.FirstName,
                        LastName     = newEmpModel.LastName,
                        MiddleName   = newEmpModel.MiddleName,
                        PositionId   = position.Id,
                        DepartmentId = dept.Id
                    };

                    emp = empsRepo.Create(emp);

                    formatter.Serialize(_stream, ResponseTypes.Data);
                    formatter.Serialize(_stream, new EmployeeModel
                    {
                        FirstName  = emp.FirstName,
                        LastName   = emp.LastName,
                        Id         = emp.Id,
                        MiddleName = emp.MiddleName,
                        Position   = position.Name,
                        Department = dept.Name
                    });

                    LoggerEvs.writeLog("Emp created");
                }
                catch (Exception ex)
                {
                    formatter.Serialize(_stream, ResponseTypes.Error);
                    formatter.Serialize(_stream, ex.Message);
                    Console.WriteLine(ex.Message);
                }
                break;

            case RequestTypes.CreatePayoutType:
                LoggerEvs.writeLog("Create payout type request");
                var newPayoutTypeModel = (PayoutTypeModel)formatter.Deserialize(_stream);

                try
                {
                    payoutTypesRepo.Create(new PayoutType
                    {
                        Name = newPayoutTypeModel.Name
                    });

                    formatter.Serialize(_stream, ResponseTypes.Data);

                    LoggerEvs.writeLog("Payout type created");
                }
                catch (Exception ex)
                {
                    formatter.Serialize(_stream, ResponseTypes.Error);
                    formatter.Serialize(_stream, ex.Message);
                    Console.WriteLine(ex.Message);
                }
                break;

            case RequestTypes.EditPayoutType:
            {
                LoggerEvs.writeLog("Edit payout type");

                var payoutType = (PayoutTypeModel)formatter.Deserialize(_stream);

                var pt = payoutTypesRepo.Get(payoutType.Id);

                pt.Name = payoutType.Name;

                payoutTypesRepo.Update(pt);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Payout type updated");
                break;
            }

            case RequestTypes.RemovePayoutType:
            {
                LoggerEvs.writeLog("Remove payout type");

                var payoutTypeId = (int)formatter.Deserialize(_stream);

                var payoutType = payoutTypesRepo.Get(payoutTypeId);
                payoutTypesRepo.Delete(payoutType);

                formatter.Serialize(_stream, ResponseTypes.Data);

                LoggerEvs.writeLog("Payout type removed");
                break;
            }
            }
        }
示例#24
0
 private void takeTask211()
 {
     Lab.task = new Task211();
     LoggerEvs.writeLog("С этого момента расчитывается задача #2.1.1.");
 }