Exemple #1
0
        string RunCalculation(string pSourceFile)
        {
            EntropyCalculator ec = new EntropyCalculator()
            {
                ResultDir = resultPath
            };

            ec.RunCalculation(pSourceFile);
            ec.WaitForAll();
            return(ec.ResultFile);
        }
Exemple #2
0
 /// <summary>Entrópia számítás.</summary>
 /// <param name="pSourceFile">Feldolgozandó adatfájl.</param>
 public static void RunCalculation(string pSourceFile)
 {
     try
     {
         ec = new EntropyCalculator();
         System.Console.Write(C_StartEntropyText);
         ec.RunCalculation(pSourceFile);
         SetAndStartDotTimer();
         ec.WaitForAll();
         timer.Stop();
         WriteEndInfo();
     }
     catch (Exception ex)
     {
         Environment.ExitCode = (int)ExitCode.CalculationError;
         System.Console.WriteLine();
         System.Console.WriteLine($"{C_EndEntropyText} {C_CalculationError}");
         throw ex;
     }
 }
Exemple #3
0
        private void RunAnalyticsButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (!File.Exists(tbFile.Text))
                {
                    MessageBox.Show("Nem létezik a megadott fájl!");
                    return;
                }

                if (extension == ".xml")
                {
                    XElement result = XElement.Load(tbFile.Text);
                    StatisticsGrid.DataContext = result;
                    DataPanel.Visibility       = Visibility.Visible;
                    return;
                }

                IsEnabled = false;

                LoadingAnimation.Visibility = Visibility.Visible;
                DataPanel.Visibility        = Visibility.Hidden;
                DataText.Text = File.ReadAllText(tbFile.Text);

                ec = new EntropyCalculator();
                ec.RunCalculation(tbFile.Text);

                Run r = (Run)LoadingAnimation.FindName("info");
                r.Text = $"{ec.RunningThreadCount} száll dolgozik";

                worker.DoWork             += Worker_DoWork;
                worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
                worker.RunWorkerAsync();
            }
            catch (Exception ex)
            {
                IsEnabled = true;
                LoadingAnimation.Visibility = Visibility.Hidden;
                MessageBox.Show($"A feldolgozás nem sikerült! {Environment.NewLine}Hiba: {ex.Message}", "Hiba");
            }
        }
Exemple #4
0
 public void SetUp()
 {
     entropyCalculator = new EntropyCalculator();
 }
Exemple #5
0
		private static void OutputEntropy( string str ) {
			double entropy = EntropyCalculator.CalculateEntropy( str );
			Console.WriteLine( $"Entropy of '{str}': {entropy}" );
		}
        /// <summary>
        /// Непосредственно вычисление значения
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void вычислениеЗначенияToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                using (var calcDlg = new calculateDlg())                                                                       // Создаём экземпляр диалоговой формы
                {
                    var result = calcDlg.ShowDialog();                                                                         // Вызываем диалоговую форму, запрашиваем у пользователя входные данные

                    if (result == DialogResult.OK)                                                                             // Постараюсь как можно внятнее растолковать, что тут происходит...
                    {
                        double[] full_table_head_rows = getDoubleValuesFromHeadersOfRows();                                    // Заголовки строк для области данных во всей таблице
                        double[] full_table_head_cols = getDoubleValuesFromHeadersOfColumns();                                 // Заголовки для столбцов из области данных во всей таблице
                        double[,] full_table_data = getDoubleValuesFromData();                                                 // Непосредственно табличные значения из области данных, тоже вся таблица

                        int[] iter_matrix_rows_indexes = InterpolSearch.Execute(full_table_head_rows, calcDlg.hammingDist);    // Индексы заголовков строк искомых элементов в массиве, созданном выше. Важный момент, этот индекс не соответствует индексу из таблицы, что у пользователя на экране.
                        int[] iter_matrix_cols_indexes = InterpolSearch.Execute(full_table_head_cols, calcDlg.standDeviation); // Индексы заголовков столбцов для искомых в таблице данных

                        double[] iter_matrix_row_heads = new double[2];                                                        // Непосредственно заголовки строк искомых элементов
                        double[] iter_matrix_col_heads = new double[2];                                                        // Заголовки столбцов искомых элементов

                        for (int i = 0; i < 2; i++)                                                                            // Присваиваем значения двум последним массивам
                        {
                            iter_matrix_col_heads[i] = full_table_head_cols[iter_matrix_cols_indexes[i]];
                            iter_matrix_row_heads[i] = full_table_head_rows[iter_matrix_rows_indexes[i]];
                        }

                        double[,] iter_matrix = new double[2, 2]; // Здесь будут храниться табличные данные, над которыми будут производиться вычисления

                        // Запись преобразуемых табличных данных в двумерный массив, который будет обрабатываться дальше
                        for (int i = 0; i < 2; i++)
                        {
                            for (int j = 0; j < 2; j++)
                            {
                                iter_matrix[i, j] = full_table_data[iter_matrix_rows_indexes[i], iter_matrix_cols_indexes[j]];
                            }
                        }

                        string full_answer_str = ""; // Эта строка содержит полный ответ, который затем будет выведен в файл
                        string tmp_ans_str;          // Строка, куда будут записываться промежуточные результаты

                        tmp_ans_str = string.Format("Усреднение найденных значений: {0} бит", EntropyCalculator.calculate(iter_matrix));
                        MessageBox.Show(tmp_ans_str);                                                                                                                // Выводим среднее значение
                        full_answer_str += tmp_ans_str + '\n';                                                                                                       // Записываем

                        double iter_entropy = 0;                                                                                                                     // Значение энтропии, вычисленное на каждой итерации

                        IterTableStruct iter_table = new IterTableStruct();                                                                                          // Структура таблицы
                        iter_table.matrix         = iter_matrix;                                                                                                     // Записываем начальные табличные значения
                        iter_table.row_headers    = iter_matrix_row_heads;                                                                                           // Записывам заголовки строк
                        iter_table.column_headers = iter_matrix_col_heads;                                                                                           // Записываем заголовки столбцов

                        bool continue_iter = true;                                                                                                                   // Логическая переменная, отвечающая за то, продолжать ли вычисления
                        uint counter       = 0;                                                                                                                      // Счётчик итераций

                        while (continue_iter)                                                                                                                        // Пока пользователь говорит, что хочет продолжить
                        {
                            TableExtender iterTableExter = new TableExtender(iter_table);                                                                            // Создаём экземпляр класса для расширения таблицы на текущей итерации
                            iterTableExter.extend();                                                                                                                 // Расширяем таблицу

                            iter_table = iterTableExter.getNewMatrix(calcDlg.hammingDist, calcDlg.standDeviation);                                                   // Получаем новую таблицу

                            iter_entropy = EntropyCalculator.calculate(iter_table.matrix);                                                                           // Вычисляем среднее значение энтропии на данной итерации

                            tmp_ans_str      = string.Format("Результат по {0}-й итерации: {1} бит", Convert.ToString(counter + 1), Convert.ToString(iter_entropy)); // Записываем промежуточный результат
                            continue_iter    = ErrorHandler.processingQuestion(tmp_ans_str + ". Продолжить вычисления?");                                            // Выводим промежуточный результат
                            full_answer_str += tmp_ans_str + '\n';                                                                                                   // И записываем его в ответ

                            if (continue_iter)
                            {
                                counter++; // Увеличиваем счётчик
                            }
                        }

                        string file_name = "ans.txt"; // Имя файла для записи

                        if (File.Exists(file_name))   // Если он существует - удаляем
                        {
                            File.Delete(file_name);
                        }

                        using (FileStream file = File.OpenWrite(file_name))                     // Создаём файловый поток для создания файла и работы с ним
                            using (StreamWriter writer = new StreamWriter(file, Encoding.UTF8)) // Создаём поток для записи в файл
                                writer.Write(full_answer_str);                                  // Записываем данные в файл

                        Process.Start(file_name);                                               // Запускаем файл
                    }
                }
            }

            catch (Exception ex)
            {
                ErrorHandler.showErrorMessage(ex.Message + '\n' + ex.StackTrace);
            }
        }
 public void TestMixAveraging()
 {
     Assert.AreEqual(EntropyCalculator.calculate(new double[, ] {
         { 6.8, 4 }, { 45.9, 24 }
     }), 20.175);
 }
 public void TestDoubleAveraging()
 {
     Assert.AreEqual(EntropyCalculator.calculate(new double[, ] {
         { 10.2, 26.4 }, { 4.8, 3.14 }
     }), 11, 135);
 }
 public void TestIntAveraging()
 {
     Assert.AreEqual(EntropyCalculator.calculate(new double[, ] {
         { 3, 10 }, { 12, 25 }
     }), 12.5);
 }
 public void ClassInitialize()
 {
     ec = new EntropyCalculator();
     Assert.IsTrue(ec.SourceDataFile == string.Empty);
     InitTest();
 }