static public Dictionary <int, int> StringToEquipement(string Str) { // 1,134|2,18 Dictionary <int, int> Chans = new Dictionary <int, int>(); if (Str.Length <= 0) { return(Chans); } foreach (string Kp in Str.Split('|')) { if (Kp.Length <= 0) { continue; } int ChannelId = int.Parse(Kp.Split(',')[0]); int ItemId = int.Parse(Kp.Split(',')[1]); if (!Chans.ContainsKey(ChannelId)) { Chans.Add(ChannelId, ItemId); } } return(Chans); }
public override int GetHashCode() { int hash = 1; if (IntegratorEnable != false) { hash ^= IntegratorEnable.GetHashCode(); } if (IntegratorSaturationLevel != 0D) { hash ^= IntegratorSaturationLevel.GetHashCode(); } if (Kp != 0D) { hash ^= Kp.GetHashCode(); } if (Ki != 0D) { hash ^= Ki.GetHashCode(); } if (Kd != 0D) { hash ^= Kd.GetHashCode(); } if (Kaw != 0D) { hash ^= Kaw.GetHashCode(); } if (OutputSaturationLevel != 0D) { hash ^= OutputSaturationLevel.GetHashCode(); } return(hash); }
static public Dictionary <int, Color> StringToChannels(string Str) { // 1,18:20:25:45|2,457:154:651:0 Dictionary <int, Color> Chans = new Dictionary <int, Color>(); if (Str.Length <= 0) { return(Chans); } foreach (string Kp in Str.Split('|')) { if (Kp.Length <= 0) { continue; } int ChannelId = int.Parse(Kp.Split(',')[0]); Color Col = StringToColor(Kp.Split(',')[1]); if (!Chans.ContainsKey(ChannelId)) { Chans.Add(ChannelId, Col); } } return(Chans); }
public string T_End() { double max = 0; for (int i = 0; i < WorkList.Count; i++) { if (WorkList[i].end_x > max) { max = WorkList[i].end_x; } } double T = (max - 50) / interval_vertical; int sum_node_weight = 0; for (int i = 0; i < TopListNew.Count; i++) { sum_node_weight += TopListNew[i].weight; } Kp = sum_node_weight / T; Ke = Kp / TopListCSNew.Count; Keap = Tkr / T; return("Tкрг = " + Tkr + "\nT = " + T + "\nKпр = " + Kp.ToString("N2") + "\nКе = " + Ke.ToString("N2") + "\nКеап = " + Keap.ToString("N2") + "\n"); }
private void button_Click(object sender, RoutedEventArgs e) { try { double L, H, W, Ipa, Lpa, Kp; if (double.Parse(ValueL.Text) < 300 && double.Parse(ValueL.Text) > 0) { L = 300; ValueL.Text = "300"; } if (double.Parse(ValueL.Text) > 3000) { L = 3000; ValueL.Text = "3000"; } else { L = double.Parse(ValueL.Text); } if (double.Parse(ValueH.Text) < 300 && double.Parse(ValueH.Text) > 0) { H = 300; ValueH.Text = "300"; } if (double.Parse(ValueH.Text) > 3000) { H = 3000; ValueH.Text = "3000"; } else { H = double.Parse(ValueL.Text); } W = double.Parse(ValueW.Text); Lpa = ((H - 2 * W) * (L - 2 * W)) / 1000; Kp = (H + H + L + L) / 1000; Ipa = (H * L) / 1000; Ikkuna.Width = L / 10; Ikkuna.Height = H / 10; txtLpa.Text = Lpa.ToString("0.00") + "m²"; txtKp.Text = Kp.ToString("0.00") + "m²"; txtIpa.Text = Ipa.ToString("0.00") + "m"; } catch (Exception) { ValueH.Text = "0"; ValueL.Text = "0"; ValueW.Text = "45"; } }
void UpdateConfig() { try { if (this.TxtBoxKp.InvokeRequired) { this.Invoke(new UpdateConfigCallback(UpdateConfig)); } else { TxtBoxKp.Text = Kp.ToString(); TxtBoxKi.Text = Ki.ToString(); TxtBoxKd.Text = Kd.ToString(); TxtBoxErrorMax.Text = ErrorMax.ToString(); TxtBoxPWMPeriod.Text = PWMPeriod.ToString(); TxtBoxIntMax.Text = IntMax.ToString(); } } catch (Exception ex) { return; } }
/// <summary> /// Ken Detects common candlestick patterns and marks them on the chart. /// </summary> /// <returns></returns> public Indicator.KenCandleStickPattern KenCandleStickPattern(Data.IDataSeries input, Kp pattern, int trendStrength) { if (InInitialize && input == null) throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method"); return _indicator.KenCandleStickPattern(input, pattern, trendStrength); }
public void Save(ConfigNode node) { node.SetValue("Kp", Kp.ToString()); node.SetValue("Ki", Ki.ToString()); node.SetValue("Kd", Kd.ToString()); }
// ---------------------------------------------------------------------------------- // -------- ОСНОВНАЯ ФУНКЦИЯ РАСЧЕТА ------------------------------------------------ // весовых коэффициентов калибровки датчика с помощью МНК // ---------------------------------------------------------------------------------- public Matrix <double> CalcCalibrCoef(Matrix <double> Rmtx, Matrix <double> Umtx, Matrix <double> Pmtx, Matrix <double> Tmtx, double Pmax, Matrix <double> gammaP, Matrix <double> gammaT) { Matrix <double> resultBmtx; // Возвращаемое значение - Матрица калибровочных коэффициентов //// -1 если не верные данные о погрешностях из текстового файла //// -2 если не верные входные данные (не согласованые матрицы) //// -3 если маскимальный ВПИ! равен 0 //// -4 если рассчитанная матрица допустимых отклонений Fdop имеет нулевые значения Matrix <double> Kp; // Матрица коэффициентов пернастройки(стартовая) Matrix <double> Fdop; // Матрица допустимых отклонений Fdop (стартовая) Matrix <double> Fr; // Матрица допустимых отклонений Fdop (расчетная) Matrix <double> Fkn1; // Матрица фактических отклонений Fkn1 (стартовая с единичными весами) Matrix <double> Fkn; //Рассчитываем фактические отклонения Fkn (расчетная) Matrix <double> M1; // Матрица весов (стартовая, единичная) Matrix <double> M; // Матрица весов (расчетная) Matrix <double> M_opt; // Матрица весов (оптимальная) double maxValueM; // максимальное значение веса матрицы M Matrix <double> B1; // Матрица весовых коэффициентов (стартовая, для единичных весов) Matrix <double> B; // Матрица весовых коэффициентов (расчетная, промежуточная) int Ndop; // Количество точек в допуске int Nmax; // Общее количество точек (число элементов в матрице) int Kf_opt; // Оптимальный Kf double Kmult_opt; // Оптимальный Kmult int Tdw_out_res; // Промежуточный счетчик циклов подряд без решения int Tdw_out_res_max; // Предельное значение промежуточного счетчика циклов подряд без решения bool Exit_dw; // Критерий выхода из цикла do -while // ---------- ЭТАП-1 ------------------------------------------------------------ // ПОДГОТОВКА ДАННЫХ ДЛЯ РАСЧЕТА // ------------------------------------------------------------------------------ // Определяем количество строк и столбцов входных матриц int rowP = Pmtx.RowCount; // Количество строк матрицы Pmtx int colP = Pmtx.ColumnCount; // Количество столбцов матрицы Pmtx int rowU = Umtx.RowCount; // Количество строк матрицы Umtx int colU = Umtx.ColumnCount; // Количество столбцов матрицы Umtx int rowR = Rmtx.RowCount; // Количество строк матрицы Rmtx int colR = Rmtx.ColumnCount; // Количество столбцов матрицы Rmtx int colT = Tmtx.ColumnCount; // Количество столбцов матрицы Rmtx // Проверяем на соответствие размерности матриц if ((rowP != rowU) || (rowU != rowR) || (colP != colU) || (colU != colR) || (colR != colT)) { resultBmtx = DenseMatrix.Create(1, 1, -2); // возвращаем: -2 не верные входные данные return(resultBmtx); } // Проверка данныхпогрешностей Pa, Pb, Ta, Tb, из текстового файла if ((gammaP.ColumnCount < 2) || (gammaP.RowCount != 3) || (gammaT.ColumnCount != 2) || (gammaT.RowCount != 1)) { resultBmtx = DenseMatrix.Create(1, 1, -1); // возвращаем: -1 не верные данные о погрешностях из текстового файла return(resultBmtx); } // Проверка Pmax на ноль if (Pmax == 0) { resultBmtx = DenseMatrix.Create(1, 1, -3); // возвращаем: -3 маскимальный ВПИ! равен 0 - это ошибка return(resultBmtx); } // Если размерности входных данных согласованы // Определяем общее количество точек (число элементов в матрице) Nmax = rowP * colP; // Нормируем матрицу P //Это можно перенести пораньше, сразу после формирования матрицы P и определения Pmax Matrix <double> Pn = DenseMatrix.Create(rowP, colP, 0); for (int i = 0; i < rowP; i++) { for (int j = 0; j < colP; j++) { Pn[i, j] = Pmtx.At(i, j) / Pmax; } } // Формируем единичную матрицу весов M M1 = DenseMatrix.Create(rowP, colP, 1); M_opt = M1; // Рассчитываем матрицу коэффициентов B1(при единичной матрице весов М) B1 = CalcB(rowP, colP, M1, Pn, Umtx, Rmtx); if ((B1.RowCount == 1) && (B1.At(0, 0) == -1)) { resultBmtx = DenseMatrix.Create(1, 1, 0); // возвращаем: -1 решения нет return(resultBmtx); } // ФОРМИРОВАНИЕ СТАРТОВОЙ РАСЧЕТНОЙ ГРАНИЦЫ // Составляем матрицу коэффициентов пернастройки, где все Kp = 0 Kp = DenseMatrix.Create(rowP, colP, 0); double Kpmax = -1; // Составляем матрицу коэффициентов пернастройки Kp, кроме точек, где P(i, j) == 0 for (int i = 0; i < rowP; i++) { for (int j = 0; j < colP; j++) { if (Pmtx.At(i, j) != 0) { Kp[i, j] = Pmax / Math.Abs(Pmtx.At(i, j)); //abs(P(i, j)), чтобы обеспечить универсальность формулы относителньо вида давления(ДД, ДИВ, ДА и пр) { if (Kp[i, j] > Kpmax) { Kpmax = Kp.At(i, j); } } } } } // Ограничение на Kpmax if (Kpmax > Kpmax_dop) { Kpmax = Kpmax_dop; } // Окончательное формирование матрицы коэффициентов пернастройки Kp for (int i = 0; i < rowP; i++) { for (int j = 0; j < colP; j++) { if ((Kp.At(i, j) == 0) || (Kp.At(i, j) > Kpmax)) { Kp[i, j] = Kpmax; } } } // Рассчитываем матрицу допустимых отклонений Fdop(размерностью N, K) // Внутри функции должно быть определение какой тип датчика (ЭнИ - 100 или ЭнИ - 12, или может быть другой новый тип) Fdop = CalcFdop(rowP, colP, Kf, Kp, Tmtx, Tnku, gammaP, gammaT); // Проверка рассчитанной матрицы допустимых отклонений Fdop на отсутствие нулевых элементов // Если нулевые элементы есть, следовательно нет решения, выходим из функции (возвращаем -1) int ind = 0; bool flag = true; while ((ind < rowP) && (flag)) { for (int j = 0; j < colP; j++) { if (Fdop.At(ind, j) == 0) { flag = false; break; } } ind = ind + 1; } if (flag == false) { resultBmtx = DenseMatrix.Create(1, 1, -4); // возвращаем: -4 return(resultBmtx); } //Рассчитываем фактические отклонения Fkn(формула 5, стр. 10) Fkn1 = CalcFkn(rowP, colP, B1, Rmtx, Umtx, Pn, Kp); // ---------- ЭТАП - 2 -------------------------------------------------------- // ОСНОВНОЙ АЛГОРИТМ РАСЧЕТА // ПОИСК Kf // ---------------------------------------------------------------------------- // Флаг решение false - не найдено, true - найдено bool flagFindR = false; bool flagExitCalc = false; double dM = 0; maxValueM = 0; Kf_opt = 6; for (int Kf = 1; Kf < Kpmax_dop; Kf++) // Изменил предельное значение "10" на "Kpmax_dop" { // Рассчитываем матрицу допустимых отклонений Fdop для заданного Kf Fdop = CalcFdop(rowP, colP, Kf, Kp, Tmtx, Tnku, gammaP, gammaT); // Формируем расчетную матрицу Fr(на старте она равна допускаемой Fdop) Fr = Fdop; // Формируем матрицу единичных весовов М (на старте она равна единичной матрице) M = M1; M = DenseMatrix.Create(rowP, colP, 1); // Вычисляем матрицу фактических отклонений Fkn(на старте она равна фактическим отклонениям при единичных весовых коэффициентах) Fkn = Fkn1; // Определяем кол - во точек в допуске Ndop = CalcNdop(rowP, colP, Fkn1, Fr); // Если не все точки в допуске if (Ndop < Nmax) { //maxValueM = 0; // Организуем цикл по а до Amax for (int a = 0; a < Amax; a++) { flagExitCalc = false; // Перерассчитываем веса матрицы М for (int N = 0; N < rowP; N++) { for (int K = 0; K < colP; K++) { // нужна проверка для Fr(N, K) не равно нулю, если равно, то выходим из расчета if (Fr.At(N, K) != 0) { dM = KdM * (Fkn.At(N, K) - Fr.At(N, K)) * M.At(N, K) / Fr.At(N, K); M[N, K] = Math.Round(M.At(N, K) + dM, 4); //M[N, K] = M.At(N, K) + dM; } else { flagExitCalc = true; break; } } if (flagExitCalc) { break; } } // Перерассчитываем коэф.полинома В для новой матрицы весом М B = CalcB(rowP, colP, M, Pn, Umtx, Rmtx); // Перерассчитываем фактические отклонения Fkn для новых коэф В Fkn = CalcFkn(rowP, colP, B, Rmtx, Umtx, Pn, Kp); // Определяем кол - во точек в допуске Ndop = CalcNdop(rowP, colP, Fkn, Fr); // Если все точки в допуске решение найдено if (Ndop == Nmax) { flagFindR = true; break; } // если нет else { // Находим максимальное значение эл.матрицы М maxValueM = maxValMatrix(M); // Проверяем превышают ли веса М максимально допустимое Mmax if (maxValueM > Mmax) { // если да, то выходим из цикла по Amax break; } } // для if (Ndop == Nmax) } // for (int a = 0; a < Amax; a++) } else { // Решение найдено, устанавливаем флаг flagFindR = true; } // для if (Ndop ~= Nmax) // Если решение найдено(флаг = 1) выходим из цикла if (flagFindR) { Kf_opt = Kf; break; } } // для for Kf = 1 : 1 : 10 if ((Kf == Kpmax_dop) && (flagFindR == false)) { // Изменил в условие "Kf == 10" на условие "Kf == Kpmax_dop" ПЕРЕИМЕНОВАТЬ Kf в Kf_opt до конца кода Kf_opt = 6; } // Рассчитываем матрицу допустимых отклонений Fdop для заданного Kf Fdop = CalcFdop(rowP, colP, Kf_opt, Kp, Tmtx, Tnku, gammaP, gammaT); // ---------- ЭТАП - 3 ----------------------------------------------------- // ОСНОВНОЙ АЛГОРИТМ РАСЧЕТА // ПОИСК ОПТИМАЛЬНОГО РЕШЕНИЯ // ------------------------------------------------------------------------- // Рассчет r_opt double r = 0; double r_opt; maxValueM = 0; for (int N = 0; N < rowP; N++) { for (int K = 0; K < colP; K++) { r = r + Math.Abs(Fkn1.At(N, K) / Fdop.At(N, K)); } } r_opt = r / Nmax; double Kmult = 1; while (Kmult >= 0.1) { // Задаем, обновляем переменные //Tdw = 0; // счетчик всех циклов do -while //Tdw_opt = 0; // количество найденных не оптимальных решений подряд //Tdw_opt_max = 50; // макс.кол - во решений в допуске но НЕ оптимальных Tdw_out_res = 0; // промежуточный счетчик циклов подряд без решения Tdw_out_res_max = 50; // предельное значение промежуточного счетчика циклов подряд без решения //Tdw_out_res_sum = 0; // общий счетчик циклов в сумме без решения //Tdw_out_res_sum_max = 100; // предельное количество циклов в сумме без решения //Res_count = 0; // счетчик найденных решений //Res_count_max = 100; // максимальное количество найденных решений Exit_dw = false; // критерий выхода из цикла do -while // Формируем матрицу единичных весовов М M = M1; //M = DenseMatrix.Create(rowP, colP, 1); // Вычисляем матрицу фактических отклонеий Fkn Fkn = Fkn1; // Формируем стартовую рассчетную границу(для заданного Kmult) Fr = Fdop.Multiply(Kmult); while (Exit_dw == false) { flagExitCalc = false; //Tdw = Tdw + 1; // Считаем количество всех циклов do -while //Tdw_out_res_sum = Tdw_out_res_sum + 1; // Считаем количество всех циклов do -while в сумме без решения, независимо от того было ли найдено решение или нет // Расчет коэффициентов B B = CalcB(rowP, colP, M, Pn, Umtx, Rmtx); // Рассчитываем фактические отклонения Fkn(формула 5, стр. 10) Fkn = CalcFkn(rowP, colP, B, Rmtx, Umtx, Pn, Kp); // Определяем кол - во точек в допуске Ndop = CalcNdop(rowP, colP, Fkn, Fr); // Если все точки в допуске решение найдено if (Ndop == Nmax) { //Tdw_opt = Tdw_opt + 1; // Считаем количество найденных решений подряд, как только решение отсутствует, параметр обнуляется // Расчет среднего значения относительного отклонения по модулю r = 0; for (int N = 0; N < rowP; N++) { for (int K = 0; K < colP; K++) { r = Math.Round(r + Math.Abs(Fkn.At(N, K) / Fdop.At(N, K)), 4); } } r = r / Nmax; // Сравниваем текущую r с r_opt, если r меньше, то перезаписываем r_opt if (r < r_opt) { // Оптимальное решение найдено r_opt = r; M_opt = M; Kmult_opt = Kmult; //Tdw_opt = 0; } // Считаем общее количество найденных решений, независимо от того, было ли отсутствие решения //Res_count = Res_count + 1; Tdw_out_res = 0; // обнуляем промежуточный счетчик циклов без решения, в связи с найденным решением // Понижение расчетной границы Fr Fr = CalcFr_cur(rowP, colP, Fr, Fkn, deltaFdop_min, Fr_min, deltaFkn_min); //если не все точки в допуске(решение не найдено) } else { // увеличиваем промежуточный счетчик циклов без решения Tdw_out_res = Tdw_out_res + 1; } // Перерассчитываем веса матрицы М for (int N = 0; N < rowP; N++) { for (int K = 0; K < colP; K++) { // нужна проверка для Fr(N, K) не равно нулю, если равно, то выходим из расчета if (Fr.At(N, K) != 0) { dM = KdM * (Fkn.At(N, K) - Fr.At(N, K)) * M.At(N, K) / Fr.At(N, K); M[N, K] = M.At(N, K) + dM; nm++; } else { flagExitCalc = true; break; } } if (flagExitCalc) { break; } } // Находим максимальное значение элементов матрицы М maxValueM = maxValMatrix(M); // Проверка условий выхода их цикла do -while // 1.Если общее количество найденных решений Res_count, независимо от того, было ли отсутствие решения, больше, чем максимальное // значение этого параметра Res_count_max, то выход из do -while // 2.Если максимальное значение элементов матрицы М maxVal больше, чем Mmax, то выходим // 3.Если общий счетчик циклов в сумме без решения // Tdw_out_res_sum больше, чем допускаемое количество Tdw_out_res_sum_max, то выходим // 4.Если количество найденных не оптимальных решений подряд Tdw_opt больше, чем допускаемое количество Tdw_opt_max, то выходим. if ((maxValueM > Mmax) || (Tdw_out_res > Tdw_out_res_max)) { Exit_dw = true; // критерий выхода из цикла do -while } } // для while(Exit_dw == 0) Kmult = Kmult - 0.3; } // для for Kmult = 1 : -0.1 : 0.1 // ----------ЭТАП - 4-------------------- // ОБРАБОТКА РЕЗУЛЬТАТОВ // -------------------------------------- nm = nm + 0; // Расчет коэффициентов B Matrix <double> BmtxRes = DenseMatrix.Create(24, 1, 0); // Расчет коэффициентов B BmtxRes = CalcB(rowP, colP, M_opt, Pn, Umtx, Rmtx); // Рассчитываем фактические отклонения Fkn(формула 5, стр. 10) Fkn = CalcFkn(rowP, colP, BmtxRes, Rmtx, Umtx, Pn, Kp); resultBmtx = DenseMatrix.Create(24, 1, 0); resultBmtx = BmtxRes; return(resultBmtx); // КОНЕЦ РАСЧЕТА // /* * * * * // ФУНКЦИЯ ОБНУЛЕНИЯ ДАТЧИКА * //------------------------------------------------------------------------- * // В этой функции серьезные проблемы с универсальностью. Буду думать уже в * // отпуске. Не успел подумать. Точка по давлению 0 может отсутствовать! И * // как быть в этом случае. Обнулить ближайшую к нулю точку по давлению? Буду * // думать.А можно точку ноль аппроксимировать и потом обнулять ? * // Пока это работает для ДД, ДИ, ДВ. * //------------------------------------------------------------------------- * * // Ищем координаты точки с нулевым давлением и на НКУ. * int col = -1; * for (int i = 0; i < Tmtx.ColumnCount; i++) * { * if (Tmtx.At(0, i) == 23) * { * col = i+1; * break; * } * } * if (col == -1) * { * resultBmtx = DenseMatrix.Create(1, 1, -4); * return resultBmtx; * } * * * int row = -1; * for (int i = 0; i < rowP; i++) * { * if (Pmtx.At(i, col) == 0) * { * row = i+1; * break; * } * } * if (row == -1) * { * resultBmtx = DenseMatrix.Create(1, 1, -5); * return resultBmtx; * } * * // Ищем фактические отклонения, но с учетом знака(не по модулю как в CalcFkn) * Matrix<double> Fkn_sign = DenseMatrix.Create(rowP, colP, 0); * * // цикл по N(строкам матриц M, P, R, U) * for (int N = 0; N < rowP; N++) * { * // цикл по K(столбцам матриц M, P, R, U) * for (int K = 0; K < colP; K++) * { * double Fi = 0; * int m = 0; * // цикл по j * for (int j = 0; j < 6; j++) * { * // цикл по i * for (int i = 0; i < 4; i++) * { * Fi = Fi + BmtxRes.At(m,0) * Math.Pow(Rmtx.At(N, K), i) * Math.Pow(Umtx.At(N, K), j); * m = m + 1; * } * } * Fkn_sign[N, K] = (Fi - Pn.At(N, K)) * 100 * Kp.At(N, K); * } * } * * * // Обнуляем фактические отклонения по значению на НКУ и в 0 точке * for (int N = 0; N < rowP; N++) * { * for (int K = 0; K < colP; K++) * { * Fkn[N, K] = Math.Abs(Fkn_sign.At(N, K) / Kp.At(N, K) - Fkn_sign.At(row, col) / Kp.At(row, col)) * Kp.At(N, K); * } * } * * // Тип датчика * * Vector<double> code_acc = DenseVector.Create(gammaTa.RowCount, 0); * code_acc = gammaTa.Column(0, 0, gammaTa.RowCount); * * int code_opt = -1; * * // окончательная допускаемая граница по которой определяем код точности с учетом коэф. запаса * Matrix<double> Fdop_res = DenseMatrix.Create(rowP, colP, 0); * Matrix<double> gamma_P = DenseMatrix.Create(1, 2, 0); * Matrix<double> gamma_T = DenseMatrix.Create(1, 2, 0); * * for (int cc = 1; cc < code_acc.Count; cc++) * { * curCode = Convert.ToInt32(gammaPa.At(cc, 0)); * for (int i = 0; i < rowP; i++) * { * for (int j = 0; j < colP; j++) * { * if (Kp.At(i, j) < Kf) * { * // Получаем коэффициенты а и b осн.приведенной погрешности * gamma_P = CalcGammaP(Kp.At(i, j), curCode, gammaPa, gammaPb); * // Получаем коэффициенты а и b доп.температурной погрешности * gamma_T = CalcGammaT(curCode, sens, gammaTa, gammaTb); * // Расчет Fdop * Fdop_res[i, j] = ((gamma_P.At(0, 0) + gamma_P.At(0, 1) * Kp.At(i, j)) + (gamma_T.At(0, 0) + gamma_T.At(0, 1) * Kp.At(i, j)) * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10))*(0.5 + 0.05 * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) * 0.9; * } * * else * { * // Получаем коэффициенты а и b осн.приведенной погрешности * gamma_P = CalcGammaP(Kf, curCode, gammaPa, gammaPb); * // Получаем коэффициенты а и b доп.температурной погрешности * gamma_T = CalcGammaT(curCode, sens, gammaTa, gammaTb); * // Расчет Fdop * Fdop_res[i, j] = ((gamma_P.At(0, 0) + gamma_P.At(0, 1) * Kf) + (gamma_T.At(0, 0) + gamma_T.At(0, 1) * Kf) * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) *(0.5 + 0.05 * (Math.Abs(Tmtx.At(0, j) - Tnku) / 10)) * 0.9; * } * } * } * * Ndop = CalcNdop(rowP, colP, Fkn, Fdop_res); * * * if (Ndop == Nmax) * { * code_opt = curCode; * break; * } * } * * if (code_opt == -1) * { * resultBmtx = DenseMatrix.Create(1, 1, -1); // возвращаем: -6 не попали ни в какой код точности * return resultBmtx; * } * * resultBmtx = DenseMatrix.Create(24, 1, 0); * resultBmtx = BmtxRes; * return resultBmtx;*/ }
public void Execute() { if (arrayInput != null) { double Kp; //Kappa "language" double cipherTextLength = 0; //n double countDoubleCharacters = 0; string ciphermode = "monoalphabetic/cleartext"; //Now we set the Kappa plain-text coefficient. Default is English. switch (settings.Kappa) { case 1: Kp = 0.0762; break; case 2: Kp = 0.0778; break; case 3: Kp = 0.0770; break; case 4: Kp = 0.0738; break; case 5: Kp = 0.0745; break; default: Kp = 0.0667; break; } ShowStatusBarMessage("Using IC = " + Kp.ToString() + " for analysis...", NotificationLevel.Debug); if (arrayInput.Length < 2) { // error, only one letter? ShowStatusBarMessage("Error - cannot analyze an array of a single letter.", NotificationLevel.Error); return; } for (int i = 0; i < arrayInput.Length; i++) { cipherTextLength += arrayInput[i]; countDoubleCharacters += (arrayInput[i] * (arrayInput[i] - 1)); // show some progress ShowProgress(i, (arrayInput.Length + 1)); } ShowStatusBarMessage(String.Format("Input analyzed: Got {0} different letters in a text of total length {1}.", arrayInput.Length, cipherTextLength), NotificationLevel.Debug); kappaCiphertext = ((double)countDoubleCharacters / (double)(cipherTextLength * (cipherTextLength - 1))); keyLength = (0.0377 * cipherTextLength) / ((cipherTextLength - 1.0) * kappaCiphertext - (0.0385 * cipherTextLength) + 0.0762); if (Math.Abs(Kp - kappaCiphertext) > 0.01) { ciphermode = "polyalphabetic"; } stringOutput = String.Format("KeyLen = {0}\nIC_analyzed = {1}\nIC_provided = {2}\nMode = {3}", keyLength.ToString("0.00000"), kappaCiphertext.ToString("0.00000"), Kp, ciphermode); OnPropertyChanged("StringOutput"); OnPropertyChanged("KeyLength"); OnPropertyChanged("KappaCiphertext"); // final step of progress ShowProgress(100, 100); } }
public Indicator.KenCandleStickPattern KenCandleStickPattern(Kp pattern, int trendStrength) { return _indicator.KenCandleStickPattern(Input, pattern, trendStrength); }
public void DoWork(Object parameter) { Form1 form = parameter as Form1; bool neue_daten = false; //Stopwatch_timer Neue Messdaten Stopwatch timer_global = new Stopwatch(); timer_global.Start(); if (form == null) { return; } while (!_shouldStop) { string order; //Abfrage keyboard bool key_vor = Keyboard.IsKeyDown(Key.Up); bool key_zuruck = Keyboard.IsKeyDown(Key.Down); bool key_links = Keyboard.IsKeyDown(Key.Left); bool key_rechts = Keyboard.IsKeyDown(Key.Right); bool key_schnell = Keyboard.IsKeyDown(Key.RightShift); bool key_langsam = Keyboard.IsKeyDown(Key.RightCtrl); //Funktionstasten abfragen bool key_function1 = Keyboard.IsKeyDown(Key.A); /* * 0. S- Schnell Vor * 0. V- Normal Vor * 0. L- Langsam Vor * 0. N- Motor Aus * 0. Z- Normal Zurück * 0. R- Schnell Zurück * 1. B- links * 1. N- Ruder Neutral * 1. S- Rechts * 2. H- Handshake Anfordern * 3. P- Position Anfoderdern * * */ order = "N"; //Zuordnen if (key_vor) { order = "V"; } if (key_vor && key_schnell) { order = "S"; } if (key_vor && key_langsam) { order = "L"; } if (key_vor && key_links) { order = "B"; } if (key_vor && key_rechts) { order = "E"; } if (key_vor && key_langsam) { order = "L"; } if (key_vor && key_links && key_schnell) { order = "A"; } if (key_vor && key_links && key_langsam) { order = "C"; } if (key_vor && key_rechts && key_schnell) { order = "D"; } if (key_vor && key_rechts && key_langsam) { order = "F"; } if (key_zuruck) { order = "K"; } if (key_zuruck && key_rechts) { order = "H"; } if (key_zuruck && key_links) { order = "G"; } if (key_links && key_vor == false && key_zuruck == false) { order = "O"; } if (key_rechts && key_vor == false && key_zuruck == false) { order = "P"; } if (heading_follower == true && heading_sp <= 360 && heading_sp >= 0) { string heading_string = heading_sp.ToString(); if (heading_sp < 10) { heading_string = "0" + heading_string; } if (heading_sp < 100) { heading_string = "0" + heading_string; } order = "H" + heading_string[0].ToString() + heading_string[1].ToString() + heading_string[2].ToString(); } if (parameter_update) { order = "P" + Kp.ToString() + ";" + Kp.ToString() + ";" + Kp.ToString(); parameter_update = false; } if (serialPort1.IsOpen == true) { serial_write(order); Thread.Sleep(500); if (serialPort1.BytesToRead > 0) { string empfangen = serialPort1.ReadExisting(); } } //Neue Daten empfangen // var time=timer_global.ElapsedMilliseconds; } }
/// <summary> /// Ken Detects common candlestick patterns and marks them on the chart. /// </summary> /// <returns></returns> public Indicator.KenCandleStickPattern KenCandleStickPattern(Data.IDataSeries input, Kp pattern, int trendStrength) { return _indicator.KenCandleStickPattern(input, pattern, trendStrength); }
/// <summary> /// Ken Detects common candlestick patterns and marks them on the chart. /// </summary> /// <returns></returns> public KenCandleStickPattern KenCandleStickPattern(Data.IDataSeries input, Kp pattern, int trendStrength) { if (cacheKenCandleStickPattern != null) for (int idx = 0; idx < cacheKenCandleStickPattern.Length; idx++) if (cacheKenCandleStickPattern[idx].Pattern == pattern && cacheKenCandleStickPattern[idx].TrendStrength == trendStrength && cacheKenCandleStickPattern[idx].EqualsInput(input)) return cacheKenCandleStickPattern[idx]; lock (checkKenCandleStickPattern) { checkKenCandleStickPattern.Pattern = pattern; pattern = checkKenCandleStickPattern.Pattern; checkKenCandleStickPattern.TrendStrength = trendStrength; trendStrength = checkKenCandleStickPattern.TrendStrength; if (cacheKenCandleStickPattern != null) for (int idx = 0; idx < cacheKenCandleStickPattern.Length; idx++) if (cacheKenCandleStickPattern[idx].Pattern == pattern && cacheKenCandleStickPattern[idx].TrendStrength == trendStrength && cacheKenCandleStickPattern[idx].EqualsInput(input)) return cacheKenCandleStickPattern[idx]; KenCandleStickPattern indicator = new KenCandleStickPattern(); indicator.BarsRequired = BarsRequired; indicator.CalculateOnBarClose = CalculateOnBarClose; #if NT7 indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256; indicator.MaximumBarsLookBack = MaximumBarsLookBack; #endif indicator.Input = input; indicator.Pattern = pattern; indicator.TrendStrength = trendStrength; Indicators.Add(indicator); indicator.SetUp(); KenCandleStickPattern[] tmp = new KenCandleStickPattern[cacheKenCandleStickPattern == null ? 1 : cacheKenCandleStickPattern.Length + 1]; if (cacheKenCandleStickPattern != null) cacheKenCandleStickPattern.CopyTo(tmp, 0); tmp[tmp.Length - 1] = indicator; cacheKenCandleStickPattern = tmp; return indicator; } }
/// <summary> /// Ken Detects common candlestick patterns and marks them on the chart. /// </summary> /// <returns></returns> public KenCandleStickPattern KenCandleStickPattern(Kp pattern, int trendStrength) { return KenCandleStickPattern(Input, pattern, trendStrength); }
// ~FGPID(); public override bool Run() { double I_out_delta = 0.0; double Dval = 0; input = inputNodes[0].GetDoubleValue(); if (ProcessVariableDot != null) { Dval = ProcessVariableDot.GetValue(); } else { Dval = (input - Input_prev) / dt; } // Do not continue to integrate the input to the integrator if a wind-up // condition is sensed - that is, if the property pointed to by the trigger // element is non-zero. Reset the integrator to 0.0 if the Trigger value // is negative. double test = 0.0; if (Trigger != null) { test = Trigger.GetValue(); } if (Math.Abs(test) < 0.000001) { switch (IntType) { case eIntegrateType.eRectEuler: I_out_delta = input; // Normal rectangular integrator break; case eIntegrateType.eTrapezoidal: I_out_delta = 0.5 * (input + Input_prev); // Trapezoidal integrator break; case eIntegrateType.eAdamsBashforth2: I_out_delta = 1.5 * input - 0.5 * Input_prev; // 2nd order Adams Bashforth integrator break; case eIntegrateType.eAdamsBashforth3: // 3rd order Adams Bashforth integrator I_out_delta = (23.0 * input - 16.0 * Input_prev + 5.0 * Input_prev2) / 12.0; break; case eIntegrateType.eNone: // No integrator is defined or used. I_out_delta = 0.0; break; } } if (test < 0.0) { I_out_total = 0.0; // Reset integrator to 0.0 } I_out_total += Ki.GetValue() * dt * I_out_delta; if (IsStandard) { output = Kp.GetValue() * (input + I_out_total + Kd.GetValue() * Dval); } else { output = Kp.GetValue() * input + I_out_total + Kd.GetValue() * Dval; } Input_prev2 = test < 0.0 ? 0.0 : Input_prev; Input_prev = input; Clip(); SetOutput(); return(true); }
public static int ToInt(this Kp patterns) { return((int)patterns); }