alpha = 0.

2 # ����������� ����������
prev_rf_ma = 3 # ���������� �������� ���������� ��������
rf = 5 # ������� �������� rf
rf_ma = alpha * rf + (1 - alpha) * prev_rf_ma # ���������������� �����������
min_rf = 2
max_rf = 20
normalized = (rf_ma - min_rf) / (max_rf - min_rf)
prev_rf_ma = rf_ma # �������� ������� �������� ���������� �������� �� ��������
��������
....
rf_list = [3, 5, 2, 20] # ������ �������� rf
min_rf = min(rf_list)
max_rf = max(rf_list)
N = len(rf_list) # ��������� �������� ����
for i in range(N, len(rf_list)):
rf_ma = sum(rf_list[i-N:i]) / N # ��������� �������
normalized = (rf_ma - min_rf) / (max_rf - min_rf)
# ������ ���-�� � ��������������� ���������
N += 1 # ����������� ������ ���� �� �������� ��������
....
double rf_list[] = {3, 5, 2, 20}; // ������ �������� rf
double min_rf = MathMinArray(rf_list, 4);
double max_rf = MathMaxArray(rf_list, 4);
int N = ArraySize(rf_list); // ��������� �������� ����
for (int i = N; i < ArraySize(rf_list); i++) {
double rf_ma = 0;
for (int j = i - N; j < i; j++) {
rf_ma += rf_list[j];
}
rf_ma /= N; // ��������� �������
double normalized = (rf_ma - min_rf) / (max_rf - min_rf);
// ������ ���-�� � ��������������� ���������
N++; // ����������� ������ ���� �� �������� ��������
}
...
double alpha = 0.5; // ����������� ���� ����������� �������
double prev_normalized = ... ; // ���������� ��������������� ��������
double normalized = alpha * prev_normalized + (1 - alpha) * (rf_ma - min_rf) /
(max_rf - min_rf);
///
double normalized = (value - min) / (max - min) + prev_normalized;
...
double alpha = 0.1; // ��������� �������� ������������ ����������
double smoothed_value; // �������� ����������� ������� �����������
double prev_smoothed_value = initial_value; // ��������� �������� ��
prev_smoothed_value

for (int i = 0; i < num_iterations; i++) {

double current_value = get_current_value(); // �������� ������� ��������
������� �����������

smoothed_value = alpha * current_value + (1 - alpha) * prev_smoothed_value; //

��������� ���������������� �����������
prev_smoothed_value = smoothed_value; // ��������� �������� smoothed_value ��
�������� ��������

double normalized_value = (smoothed_value - min_value) / (max_value -

min_value); // ������������� ���������� ��������
 // ������������ ��������������� �������� � �������� ������� �����������
...
}
....
double normalized_value = alpha * prev_normalized + (1 - alpha) * (smoothed_value -
min_value) / (max_value - min_value);
..
double adjustedR2(const double& data1[], const double& data2[], const int
data_size, const int num_of_predictors) {
double r2 = pearsonCorrelation(data1, data2, data_size);
double adj_r2 = 1.0 - (1.0 - r2) * ((data_size - 1.0) / (data_size -
num_of_predictors - 1.0));
return adj_r2;
}
....
Adjusted R2 = 1 - ((1 - R2) * (n - 1) / (n - k - 1))

���:

R2 - �������� ������������ ������������ (������ ������������� � ������ �������

���������);
n - ����� ���������� ���������;
k - ���������� ����������� ���������� � ������.

//////
// ������ �� ������� ������������ ��������� �������
double pearsonCorrelation(const double& data1[], const double& data2[], const int&
data_size)
{
double sum1 = 0.0, sum2 = 0.0, sum_sq1 = 0.0, sum_sq2 = 0.0, sum_product = 0.0;
for (int i = 0; i < data_size; i++) {
sum1 += data1[i];
sum2 += data2[i];
sum_sq1 += pow(data1[i], 2);
sum_sq2 += pow(data2[i], 2);
sum_product += data1[i] * data2[i];
}
double numerator = sum_product - ((sum1 * sum2) / data_size);
double denominator1 = sum_sq1 - (pow(sum1, 2) / data_size);
double denominator2 = sum_sq2 - (pow(sum2, 2) / data_size);
double denominator = sqrt(denominator1 * denominator2);
if (denominator == 0) {
return 0.0;
} else {
return numerator / denominator;
}
}

// ������ �� ���������� ���������� ������������ ��������� �������

bool isSignificant(const double& pearson_corr_coef, const int& data_size, const
double& alpha)
{
double t = pearson_corr_coef * sqrt(data_size - 2) / sqrt(1 -
pow(pearson_corr_coef, 2));
double critical_t = StatsLib::student_t_cdf_inverse(alpha / 2, data_size - 2);
return abs(t) > critical_t;
}