Основные показатели стратегии

Математическое ожидание

Описание:	Формула
Математическое ожидание — это среднее значение случайной величины, которое ожидается в результате большого числа экспериментов или случайных событий. В контексте торговли, это важнейший показатель ожидаемой прибыльности торговой стратегии. Математическое ожидание бывает двух видов: в пунктах и валюте депозита.

Python

def calculate_expectation(profit_losses):
    n = len(profit_losses)
    expectation = sum(profit_losses) / n
    return expectation

# Использование
profit_losses = [100, -50, 75, -30, 120]  # пример прибыли/убытка от сделок
expectation = calculate_expectation(profit_losses)
print("Математическое ожидание:", expectation)

MQL5

double CalculateExpectation(double profit_losses[]) {
    int n = ArraySize(profit_losses);
    double sum = 0;
    for (int i = 0; i < n; i++) {
        sum += profit_losses[i];
    }
    double expectation = sum / n;
    return expectation;
}
// Использование
double profit_losses[] = {100, -50, 75, -30, 120};  // пример прибыли/убытка от сделок
double expectation = CalculateExpectation(profit_losses);
Print("Математическое ожидание:", expectation);

Профит фактор

Описание:	Формула
Профит фактор — это показатель, который отражает отношение общей суммы прибыли к общей сумме убытков. Чем выше значение профит фактора, тем лучше эффективность стратегии.

Python

def calculate_profit_factor(profits, losses):
    total_profit = sum(profits)
    total_loss = sum(losses)
    profit_factor = total_profit / total_loss
    return profit_factor
    
# Использование
profits = [100, 50, 75, 30, 120]  # пример прибыли от сделок
losses = [-50, -30, -20, -10, -25]  # пример убытков от сделок
profit_factor = calculate_profit_factor(profits, losses)
print("Профит фактор:", profit_factor)

MQL5

double CalculateProfitFactor(double profits[], double losses[]) {
    double total_profit = ArraySum(profits);
    double total_loss = ArraySum(losses);
    double profit_factor = total_profit / total_loss;
    return profit_factor;
}
// Использование
double profits[] = {100, 50, 75, 30, 120};  // пример прибыли от сделок
double losses[] = {-50, -30, -20, -10, -25};  // пример убытков от сделок
double profit_factor = CalculateProfitFactor(profits, losses);
Print("Профит фактор:", profit_factor);

Прибыльность

Описание:	Формула
Прибыльность — это показатель, который отражает успешность торговой стратегии или инвестиций. Он представляет собой отношение общей прибыли к общим затратам или капиталу, и может быть выражен как абсолютное значение или в процентах.	Где: Общая прибыль - сумма всех прибылей от сделок. Общий капитал - начальный капитал или текущий баланс счета. Показатель прибыльности позволяет оценить доходность стратегии или инвестиций относительно вложенных средств.

Python

def calculate_profitability(total_profit, initial_capital):
    profitability = (total_profit / initial_capital) * 100
    return profitability
# Использование
total_profit = 5000  # пример общей прибыли
initial_capital = 10000  # пример начального капитала
profitability = calculate_profitability(total_profit, initial_capital)
print("Прибыльность:", profitability, "%")

MQL5

// MQL5
double CalculateProfitability(double total_profit, double initial_capital) {
    double profitability = (total_profit / initial_capital) * 100;
    return profitability;
}

// Пример использования
double total_profit = 5000;  // пример общей прибыли
double initial_capital = 10000;  // пример начального капитала
double profitability = CalculateProfitability(total_profit, initial_capital);
Print("Прибыльность:", profitability, "%");

Максимальная абсолютная просадка

Описание:	Формула
Максимальная абсолютная просадка (Maximum Drawdown, MDD) - это показатель, отражающий максимальную величину снижения капитала от пикового значения до минимального за определенный период времени.	MDD = (Наибольшее пиковое значение капитала - Наименьшее значение капитала после пика) / Наибольшее пиковое значение капитала

Чем меньше максимальная абсолютная просадка, тем более стабильной и менее рискованной считается торговая стратегия.

Python

def calculate_max_drawdown(equity_curve):
    peak = equity_curve[0]
    max_drawdown = 0
    
    for value in equity_curve:
        peak = max(peak, value)
        dd = (peak - value) / peak
        max_drawdown = max(max_drawdown, dd)
        
    return max_drawdown

# Пример использования
equity_curve = [10000, 11000, 9500, 10200, 9800, 10500]
max_dd = calculate_max_drawdown(equity_curve)
print(f"Максимальная абсолютная просадка: {max_dd * 100:.2f}%")

MQL5

double CalculateMaxDrawdown(double &equity_curve[])
{
    int size = ArraySize(equity_curve);
    double peak = equity_curve[0];
    double max_drawdown = 0;
    
    for(int i=1; i<size; i++)
    {
        double value = equity_curve[i];
        peak = fmax(peak, value);
        double dd = (peak - value) / peak;
        max_drawdown = fmax(max_drawdown, dd);
    }
    
    return max_drawdown;
}

// Использование
double equity_curve[] = {10000, 11000, 9500, 10200, 9800, 10500};
double max_dd = CalculateMaxDrawdown(equity_curve);
Print("Максимальная абсолютная просадка: ", max_dd * 100, "%");

Максимальная относительная просадка

Описание:	Формула
Максимальная относительная просадка (Maximum Relative Drawdown, MRD) - это показатель, отражающий максимальную долю (процент) потерянного капитала от наибольшего пикового значения за определенный период времени. В отличие от максимальной абсолютной просадки, она показывает просадку в относительных единицах.	MRD = (Наибольшее пиковое значение капитала - Наименьшее значение капитала после пика) / Наибольшее пиковое значение капитала * 100%

Чем меньше максимальная относительная просадка, тем более стабильной и менее
рискованной считается торговая стратегия.

Python

def calculate_max_relative_drawdown(equity_curve):
    peak = equity_curve[0]
    max_drawdown = 0
    
    for value in equity_curve:
        peak = max(peak, value)
        dd = (peak - value) / peak * 100
        max_drawdown = max(max_drawdown, dd)
        
    return max_drawdown

# Пример использования
equity_curve = [10000, 11000, 9500, 10200, 9800, 10500]
max_rdd = calculate_max_relative_drawdown(equity_curve)
print(f"Максимальная относительная просадка: {max_rdd:.2f}%")

MQL5

double CalculateMaxRelativeDrawdown(double &equity_curve[])
{
    int size = ArraySize(equity_curve);
    double peak = equity_curve[0];
    double max_drawdown = 0;
    
    for(int i=1; i<size; i++)
    {
        double value = equity_curve[i];
        peak = fmax(peak, value);
        double dd = (peak - value) / peak * 100;
        max_drawdown = fmax(max_drawdown, dd);
    }
    
    return max_drawdown;
}

// Использование
double equity_curve[] = {10000, 11000, 9500, 10200, 9800, 10500};
double max_rdd = CalculateMaxRelativeDrawdown(equity_curve);
Print("Максимальная относительная просадка: ", max_rdd, "%");

Относительная просадка

Описание:	Формула
Относительная просадка (Relative Drawdown, RD) - это показатель, отражающий текущую величину снижения капитала относительно его максимального предыдущего значения. Она измеряет текущий уровень просадки в процентах от наибольшего пикового значения капитала.	RD = (Наибольшее пиковое значение капитала - Текущее значение капитала) / Наибольшее пиковое значение капитала * 100%

Относительная просадка помогает оценить текущий уровень потерь по сравнению с максимально достигнутым капиталом. Чем выше значение, тем больше потери на данный момент.

Python

def calculate_relative_drawdown(equity_curve):
    peak = equity_curve[0]
    drawdowns = []
    
    for value in equity_curve:
        peak = max(peak, value)
        rd = (peak - value) / peak * 100
        drawdowns.append(rd)
        
    return drawdowns

# Пример использования
equity_curve = [10000, 11000, 9500, 10200, 9800, 10500]
relative_drawdowns = calculate_relative_drawdown(equity_curve)
print("Относительные просадки:")
for rd in relative_drawdowns:
    print(f"{rd:.2f}%")

MQL5

double CalculateRelativeDrawdown(double &equity_curve[], double &drawdowns[])
{
    int size = ArraySize(equity_curve);
    double peak = equity_curve[0];
    ArrayResize(drawdowns, size);
    
    for(int i=0; i<size; i++)
    {
        double value = equity_curve[i];
        peak = fmax(peak, value);
        double rd = (peak - value) / peak * 100;
        drawdowns[i] = rd;
    }
    
    return drawdowns;
}

// Использование
double equity_curve[] = {10000, 11000, 9500, 10200, 9800, 10500};
double drawdowns[];
CalculateRelativeDrawdown(equity_curve, drawdowns);
Print("Относительные просадки:");
for(int i=0; i<ArraySize(drawdowns); i++)
    Print(drawdowns[i], "%");

Фактор восстановления

Описание:	Формула
-данный параметр отображает рискованностьстратегии, какой суммой рискует советник что бы заработать полученную прибыль. Он вычисляется как отношение полученной прибыли к максимальной просадке.	Где: Абсолютная прибыль - общая прибыль от сделок. Максимальная просадка - наибольшее уменьшение доступных средств с момента достижения максимального значения баланса.

Значения менее 2 не рассматриваем

Параметр фактор восстановление тем более правильный, чем большая история торговли обсчитывается.

Python

def calculate_recovery_factor(absolute_profit, max_drawdown):
    return absolute_profit / max_drawdown

# Пример использования
absolute_profit = 1500  # пример абсолютной прибыли
max_drawdown = 1000  # пример максимальной просадки
recovery_factor = calculate_recovery_factor(absolute_profit, max_drawdown)
print("Фактор восстановления:", recovery_factor)

MQL5

double CalculateRecoveryFactor(double absolute_profit, double max_drawdown)
{
    return absolute_profit / max_drawdown;
}

// Пример использования
double absolute_profit = 1500;  // пример абсолютной прибыли
double max_drawdown = 1000;  // пример максимальной просадки
double recovery_factor = CalculateRecoveryFactor(absolute_profit, max_drawdown);
Print("Фактор восстановления:", recovery_factor);

Процент прибыльных сделок

Описание:	Формула
Процент прибыльных сделок (Profit Factor, PF) - это показатель, который определяет долю успешных (прибыльных) сделок по отношению к общему количеству сделок за определенный период времени. Он помогает оценить эффективность торговой стратегии.	Процент прибыльных сделок = (Количество прибыльных сделок / Общее количество сделок) x 100%

Чем выше процент прибыльных сделок, тем более успешной считается торговая стратегия. Однако этот показатель не учитывает размер прибыли или убытка по каждой сделке, поэтому его следует рассматривать в совокупности с другими метриками.

Python

def calculate_profit_percent(trades):
    total_trades = len(trades)
    profitable_trades = sum(1 for trade in trades if trade > 0)
    profit_percent = (profitable_trades / total_trades) * 100
    return profit_percent

# Пример использования
trades = [100, -50, 75, -30, 120, -80, 200]
profit_percent = calculate_profit_percent(trades)
print(f"Процент прибыльных сделок: {profit_percent:.2f}%")

MQL5

double CalculateProfitPercent(double &trades[])
{
    int total_trades = ArraySize(trades);
    int profitable_trades = 0;
    
    for(int i=0; i<total_trades; i++)
    {
        if(trades[i] > 0)
            profitable_trades++;
    }
    
    double profit_percent = (double)profitable_trades / total_trades * 100;
    return profit_percent;
}

// Использование
double trades[] = {100, -50, 75, -30, 120, -80, 200};
double profit_percent = CalculateProfitPercent(trades);
Print("Процент прибыльных сделок: ", profit_percent, "%");

Максимальный выигрыш

Описание:	Формула
Максимальный выигрыш (Maximum Profit, MAX_PROFIT) - это наибольшая величина прибыли, полученная в результате одной успешной сделки за определенный период времени при использовании торговой стратегии.	MAX_PROFIT = max(прибыли от сделок)

Максимальный выигрыш показывает потенциал торговой стратегии в лучшем случае и может использоваться для оценки ее возможной доходности. Однако этот показатель не дает полной картины, поскольку он не учитывает убыточные сделки и общую стабильность стратегии.

Python

def calculate_max_profit(trades):
    profits = [trade for trade in trades if trade > 0]
    if not profits:
        return 0
    max_profit = max(profits)
    return max_profit

# Пример использования
trades = [100, -50, 75, -30, 120, -80, 200]
max_profit = calculate_max_profit(trades)
print(f"Максимальный выигрыш: {max_profit}")

MQL5

double CalculateMaxProfit(double &trades[])
{
    double max_profit = 0;
    int size = ArraySize(trades);
    
    for(int i=0; i<size; i++)
    {
        if(trades[i] > max_profit)
            max_profit = trades[i];
    }
    
    return max_profit;
}

// Использование
double trades[] = {100, -50, 75, -30, 120, -80, 200};
double max_profit = CalculateMaxProfit(trades);
Print("Максимальный выигрыш: ", max_profit);

Максимальный проигрыш

Описание:	Формула
Максимальный проигрыш (Maximum Loss, MAX_LOSS) - это наибольшая величина убытка, полученного в результате одной убыточной сделки за определенный период времени при использовании торговой стратегии.	MAX_LOSS = min(убытков от сделок)

Максимальный проигрыш показывает потенциальный риск торговой стратегии в худшем случае и может использоваться для оценки ее рискованности и управления капиталом. Однако этот показатель не дает полной картины, поскольку он не учитывает прибыльные сделки и общую стабильность стратегии.

Python

def calculate_max_loss(trades):
    losses = [trade for trade in trades if trade < 0]
    if not losses:
        return 0
    max_loss = min(losses)
    return max_loss

# Пример использования
trades = [100, -50, 75, -30, 120, -80, 200]
max_loss = calculate_max_loss(trades)
print(f"Максимальный проигрыш: {max_loss}")

MQL5

double CalculateMaxLoss(double &trades[])
{
    double max_loss = 0;
    int size = ArraySize(trades);
    
    for(int i=0; i<size; i++)
    {
        if(trades[i] < max_loss)
            max_loss = trades[i];
    }
    
    return max_loss;
}

// Использование
double trades[] = {100, -50, 75, -30, 120, -80, 200};
double max_loss = CalculateMaxLoss(trades);
Print("Максимальный проигрыш: ", max_loss);

Средний выигрыш

Описание:	Формула
Средний выигрыш - это средняя величина прибыли от одной сделки.	Средний выигрыш = (Сумма прибыльных сделок) / (Количество прибыльных сделок)

Python

def calculate_average_profit(profits, profitable_trades):
    return sum(profits) / profitable_trades

MQL5

double CalculateAverageProfit(double& profits[], int profitable_trades) {
    return ArraySum(profits) / profitable_trades;
}

Средний проигрыш

Описание:	Формула
Средний проигрыш - это средняя величина убытка от одной сделки.	Средний проигрыш = (Сумма убыточных сделок) / (Количество убыточных сделок)

Python

def calculate_average_loss(losses, losing_trades):
    return sum(losses) / losing_trades

MQL5

double CalculateAverageLoss(double& losses[], int losing_trades) {
    return ArraySum(losses) / losing_trades;
}

Максимальная череда выигрышных сделок

Описание:	Формула
Максимальная череда выигрышных сделок - это наибольшее количество последовательных прибыльных сделок.	Не требуется, это просто наибольшее количество последовательных прибыльных сделок.

Python

def calculate_max_win_streak(winning_streaks):
    return max(winning_streaks)

MQL5

int CalculateMaxWinStreak(int& winning_streaks[]) {
    return ArrayMaximum(winning_streaks);
}

Максимальная череда проигрышных сделок

Описание:	Формула
Максимальная череда проигрышных сделок - это наибольшее количество последовательных убыточных сделок.	Не требуется, это просто наибольшее количество последовательных убыточных сделок.

Python

def calculate_max_loss_streak(losing_streaks):
    return max(losing_streaks)

MQL5

int CalculateMaxLossStreak(int& losing_streaks[]) {
    return ArrayMaximum(losing_streaks);
}

Средняя череда выигрышных сделок

Описание:	Формула
Средняя череда выигрышных сделок - это среднее количество последовательных прибыльных сделок.	Средняя череда выигрышных сделок = (Сумма количества последовательных прибыльных сделок) / (Количество циклов прибыльных сделок)

Python

def calculate_average_win_streak(winning_streaks):
    return sum(winning_streaks) / len(winning_streaks)

MQL5

double CalculateAverageWinStreak(int& winning_streaks[]) {
    return ArraySum(winning_streaks) / ArraySize(winning_streaks);
}

Средняя череда проигрышных сделок

Описание:	Формула
Средняя череда проигрышных сделок - это среднее количество последовательных убыточных сделок.	Средняя череда проигрышных сделок = (Сумма количества последовательных убыточных сделок) / (Количество циклов убыточных сделок)

Python

def calculate_average_loss_streak(losing_streaks):
    return sum(losing_streaks) / len(losing_streaks)

MQL5

double CalculateAverageLossStreak(int& losing_streaks[]) {
    return ArraySum(losing_streaks) / ArraySize(losing_streaks);
}

Фактор линейности

Описание:	Формула
Фактор линейности (Linearity Factor, LF) - это показатель, который оценивает линейность или стабильность роста капитала при использовании торговой стратегии. Он измеряет степень отклонения кривой капитала от идеальной прямой линии.	LF = (Конечный капитал - Начальный капитал) / (Максимальный капитал - Минимальный капитал)

Идеальное значение фактора линейности равно 1, что означает полную линейность роста капитала. Значения меньше 1 указывают на нелинейный и нестабильный рост капитала, а значения выше 1 означают, что рост капитала происходит слишком быстро, что может быть признаком высокого риска.

Python

def calculate_linearity_factor(equity_curve):
    start_capital = equity_curve[0]
    end_capital = equity_curve[-1]
    max_capital = max(equity_curve)
    min_capital = min(equity_curve)
    
    linearity_factor = (end_capital - start_capital) / (max_capital - min_capital)
    return linearity_factor

# Пример использования
equity_curve = [10000, 10500, 9800, 10200, 10700, 11000]
linearity_factor = calculate_linearity_factor(equity_curve)
print(f"Фактор линейности: {linearity_factor:.2f}")

MQL5

double CalculateLinearityFactor(double &equity_curve[])
{
    double start_capital = equity_curve[0];
    double end_capital = equity_curve[ArraySize(equity_curve)-1];
    double max_capital = equity_curve[ArrayMaximum(equity_curve)];
    double min_capital = equity_curve[ArrayMinimum(equity_curve)];
    
    double linearity_factor = (end_capital - start_capital) / (max_capital - min_capital);
    return linearity_factor;
}

// Использование
double equity_curve[] = {10000, 10500, 9800, 10200, 10700, 11000};
double linearity_factor = CalculateLinearityFactor(equity_curve);
Print("Фактор линейности: ", linearity_factor);

Коэффициент Шарпа

Описание:	Формула
Коэффициент Шарпа - это мера риска-прибыли, которая позволяет оценить доходность инвестиции или стратегии торговли относительно риска. Чем выше значение коэффициента Шарпа, тем лучше отношение доходности к риску.	Где: Средняя доходность - среднее арифметическое значение доходности инвестиции или стратегии торговли. Безрисковая ставка - ожидаемая доходность безрискового актива (например, государственных облигаций). Стандартное отклонение доходности - мера риска инвестиции или стратегии торговли. Показатель позволяет оценить эффективность торговой стратегии с учетом принимаемого риска.

Python

import statistics

def calculate_sharpe_ratio(returns, risk_free_rate):
    mean_return = statistics.mean(returns)
    std_dev_return = statistics.stdev(returns)
    sharpe_ratio = (mean_return - risk_free_rate) / std_dev_return
    return sharpe_ratio

# Пример использования
returns = [0.05, 0.03, 0.07, 0.02, 0.06]  # пример доходностей
risk_free_rate = 0.02  # пример безрисковой ставки
sharpe_ratio = calculate_sharpe_ratio(returns, risk_free_rate)
print("Коэффициент Шарпа:", sharpe_ratio)

MQL5

double CalculateSharpeRatio(double returns[], double risk_free_rate)
{
    int n = ArraySize(returns);
    double mean_return = ArraySum(returns) / n;
    double sum_squared_difference = 0;
    for (int i = 0; i < n; i++)
    {
        sum_squared_difference += MathPow(returns[i] - mean_return, 2);
    }
    double std_dev_return = MathSqrt(sum_squared_difference / n);
    double sharpe_ratio = (mean_return - risk_free_rate) / std_dev_return;
    return sharpe_ratio;
}

// Пример использования
double returns[] = {0.05, 0.03, 0.07, 0.02, 0.06};  // пример доходностей
double risk_free_rate = 0.02;  // пример безрисковой ставки
double sharpe_ratio = CalculateSharpeRatio(returns, risk_free_rate);
Print("Коэффициент Шарпа:", sharpe_ratio);

Максимальная просадка (Drawdown)

Описание:	Формула
Максимальная просадка — это максимальное уменьшение капитала счета с начала торговой истории до момента восстановления.	Drawdown = (Максимальный убыток) / (Начальный капитал)

Python

def calculate_drawdown(max_loss, initial_capital):
    return max_loss / initial_capital

MQL5

double CalculateDrawdown(double max_loss, double initial_capital) {
    return max_loss / initial_capital;
}

Коэффициент Келли

Описание:	Формула
Коэффициент Келли помогает определить оптимальный размер ставки для максимизации прибыли при минимизации риска.	Коэффициент Келли = (p * b - q) / b Где: p - вероятность успешной сделки b - коэффициент прибыли q - коэффициент убытка

Python

def calculate_kelly_criterion(p, b, q):
    return (p * b - q) / b

MQL5

double CalculateKellyCriterion(double p, double b, double q) {
    return (p * b - q) / b;
}

Индекс Уильямса (Williams’ Percent Range)

Описание:	Формула
Z-счет - это стандартизированная мера, которая показывает, насколько значение отклоняется от среднего значения в единицах стандартного отклонения.	Z-счет = (X - Среднее) / Стандартное отклонение Где: X - значение Среднее - среднее значение Стандартное отклонение - стандартное отклонение

Python

def calculate_z_score(value, mean, std_dev):
    return (value - mean) / std_dev

MQL5

double CalculateZScore(double value, double mean, double std_dev) {
    return (value - mean) / std_dev;
}

Коэффициент детерминации $R**2$ (R-squared)

Описание:	Формула
Коэффициент детерминации — это мера, которая показывает, какую часть дисперсии зависимой переменной объясняет модель. Он представляет собой квадрат коэффициента корреляции между фактическими и прогнозируемыми значениями.	​ ​ Где:

Python

def calculate_r_squared(actual_values, predicted_values):
    mean_actual = sum(actual_values) / len(actual_values)
    sum_squared_total = sum((y - mean_actual) ** 2 for y in actual_values)
    sum_squared_residuals = sum((actual_values[i] - predicted_values[i]) ** 2 for i in range(len(actual_values)))
    r_squared = 1 - (sum_squared_residuals / sum_squared_total)
    return r_squared

Важно отметить, что коэффициент детерминации $R2$ может принимать значения от 0 до 1. Значение ближе к 1 указывает на лучшее соответствие модели данным.

MQL5

double CalculateR2(double actual_values[], double predicted_values[])
{
    int n = ArraySize(actual_values);
    double mean_actual = ArraySum(actual_values) / n;
    double sum_squared_total = 0;
    double sum_squared_residuals = 0;

    // Расчет сумм квадратов
    for (int i = 0; i < n; i++)
    {
        sum_squared_total += MathPow(actual_values[i] - mean_actual, 2);
        sum_squared_residuals += MathPow(actual_values[i] - predicted_values[i], 2);
    }

    // Расчет коэффициента детерминации
    double r_squared = 1 - (sum_squared_residuals / sum_squared_total);

    return r_squared;
}

Этот код принимает массив фактических значений (actual_values) и массив прогнозируемых значений (predicted_values) и возвращает коэффициент детерминации $R2$.

ProfitStability (Стабильность прибыли)

Описание:	Формула
Показатель "ProfitStability" отражает степень стабильности прибыли торговой стратегии. Чем выше значение этого показателя, тем более стабильной является прибыльность стратегии.	Где: Среднее значение прибыли - среднее арифметическое значение прибыли от сделок. Стандартное отклонение прибыли - мера разброса прибыли относительно её среднего значения. Чем меньше стандартное отклонение, тем более стабильной является прибыльность стратегии.

Python

import statistics

def calculate_profit_stability(profits):
    mean_profit = statistics.mean(profits)
    std_dev_profit = statistics.stdev(profits)
    return mean_profit / std_dev_profit

MQL5

double CalculateProfitStability(double profits[])
{
    int n = ArraySize(profits);
    double mean_profit = ArraySum(profits) / n;
    double sum_squared_difference = 0;
    for (int i = 0; i < n; i++)
    {
        sum_squared_difference += MathPow(profits[i] - mean_profit, 2);
    }
    double std_dev_profit = MathSqrt(sum_squared_difference / n);
    return mean_profit / std_dev_profit;
}

Этот показатель помогает оценить уровень стабильности прибыли стратегии, что может быть полезно для принятия решений о её дальнейшем использовании.

КБТС - Коэффициент безопасности торговой системы

Описание:	Формула
Коэффициент безопасности торговой системы (КБТС) позволяет оценить уровень защищенности торговой стратегии от рисков и потерь. Чем выше значение КБТС, тем более безопасной считается торговая система.	Где: Максимальная просадка - наибольшая потеря средств с момента достижения максимального баланса. Абсолютная просадка - максимальное уменьшение доступных средств с момента достижения максимального значения.

Python

def calculate_security_coefficient(max_drawdown, absolute_drawdown):
    return max_drawdown / absolute_drawdown

# Пример использования
max_drawdown = 1000  # пример максимальной просадки
absolute_drawdown = 500  # пример абсолютной просадки
security_coefficient = calculate_security_coefficient(max_drawdown, absolute_drawdown)
print("Коэффициент безопасности торговой системы:", security_coefficient)

MQL5

double CalculateSecurityCoefficient(double max_drawdown, double absolute_drawdown)
{
    return max_drawdown / absolute_drawdown;
}

// Пример использования
double max_drawdown = 1000;  // пример максимальной просадки
double absolute_drawdown = 500;  // пример абсолютной просадки
double security_coefficient = CalculateSecurityCoefficient(max_drawdown, absolute_drawdown);
Print("Коэффициент безопасности торговой системы:", security_coefficient);

КБТС позволяет оценить, во сколько раз максимальная потеря превышает максимальное уменьшение средств. Чем выше значение КБТС, тем более надежной и безопасной считается торговая стратегия.

Коэффициент вариации

Описание:	Формула
Коэффициент вариации - это статистический показатель, который измеряет степень разброса или изменчивости данных относительно среднего значения. Он представляет собой отношение стандартного отклонения к среднему значению и обычно выражается в процентах.	Коэффициент вариации = (Стандартное отклонение / Среднее значение) x 100%

Коэффициент вариации помогает оценить риск и стабильность торговой стратегии. Чем ниже его значение, тем более стабильны результаты стратегии и тем меньше разброс значений вокруг среднего. Высокий коэффициент вариации указывает на высокую изменчивость и нестабильность результатов.

Python

import math

def calculate_coefficient_of_variation(profits_losses):
    mean = sum(profits_losses) / len(profits_losses)
    squared_diffs = [(x - mean) ** 2 for x in profits_losses]
    variance = sum(squared_diffs) / len(profits_losses)
    std_dev = math.sqrt(variance)
    coefficient_of_variation = (std_dev / mean) * 100
    return coefficient_of_variation

# Пример использования
profits_losses = [100, -50, 75, -30, 120]
coefficient_of_variation = calculate_coefficient_of_variation(profits_losses)
print(f"Коэффициент вариации: {coefficient_of_variation:.2f}%")

MQL5

double CalculateCoefficientOfVariation(double &profits_losses[])
{
    double mean = 0;
    int size = ArraySize(profits_losses);
    for(int i=0; i<size; i++)
        mean += profits_losses[i];
    mean /= size;
    
    double variance = 0;
    for(int i=0; i<size; i++)
        variance += pow(profits_losses[i]-mean, 2);
    variance /= size;
    
    double std_dev = sqrt(variance);
    double coeff_of_variation = 100.0 * std_dev / mean;
    
    return coeff_of_variation;
}

// Использование
double profits_losses[] = {100, -50, 75, -30, 120};
double coeff = CalculateCoefficientOfVariation(profits_losses);
Print("Коэффициент вариации: ", coeff);