/// <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;
}
}
}
private void button1_Click(object sender, EventArgs e)
{
LoggerEvs.writeLog("Заполнение таблицы данными ряда...");
fillTable();
LoggerEvs.writeLog("Расчет математических характеристик...");
calculateTableCharacteristics();
}
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;
}
}
}
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);
}
static void Main(string[] args)
{
LoggerEvs.messageCame += testToConsole;
for (int i = 0; i < 10; i++)
{
LoggerEvs.writeLog("Test note №" + i.ToString());
}
Console.ReadKey();
}
private void открытьToolStripMenuItem_Click(object sender, EventArgs e)
{ // Открыть файл
LoggerEvs.writeLog("Открытие входной выборки...");
if (openDataInputFile())
{
LoggerEvs.writeLog("Входная выборка успешно открыта!");
}
else
{
LoggerEvs.writeLog("Ошибка при открытии входной выборки!");
}
}
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("Что-то вообще не так");
}
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);
}
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);
}
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);
}
}
}
// Проверить входные данные
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);
}
/// <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;
}
}
}
}
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++;
}
}
}
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("Проблемы с отключением от сервера.");
}
}
/// <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());
}
}
}
}
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("Построение группированного ряда частот...");
}
}
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();
}
}
}
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);
}
// Построение графиков
#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;
}
}
}
/// <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);
}
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;
}
}
}
private void takeTask211()
{
Lab.task = new Task211();
LoggerEvs.writeLog("С этого момента расчитывается задача #2.1.1.");
}