| //+------------------------------------------------------------------+
|
| //| RiskParameters.mqh |
|
| //| Copyright 2025, Your Company Name |
|
| //| https://www.yoursite.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, Your Company Name"
|
| #property link "https://www.yoursite.com"
|
| #property version "1.00"
|
| #property strict
|
|
|
| //+------------------------------------------------------------------+
|
| //| Risk Parameters Class |
|
| //+------------------------------------------------------------------+
|
| class CRiskParameters
|
| {
|
| private:
|
| // Risk parameters
|
| double m_riskPerTrade; // Risk per trade (% of equity)
|
| double m_dailyLossLimit; // Max daily loss (% of equity)
|
| double m_maxPositionSize; // Max position size (lots)
|
| double m_maxLeverage; // Maximum allowed leverage
|
| bool m_useVolatility; // Use volatility for position sizing
|
| bool m_useCorrelation; // Use correlation for risk calculation
|
|
|
| // Volatility parameters
|
| double m_volatilityFactor; // Volatility adjustment factor
|
| int m_volatilityPeriod; // Period for volatility calculation
|
|
|
| // Correlation parameters
|
| double m_maxCorrelation; // Maximum allowed correlation
|
| int m_correlationPeriod; // Period for correlation calculation
|
|
|
| // Position sizing parameters
|
| double m_minPositionSize; // Minimum position size (lots)
|
| double m_maxLotsPerTrade; // Maximum lots per trade
|
|
|
| // Internal state
|
| bool m_isInitialized; // Initialization flag
|
|
|
| public:
|
| // Constructor/Destructor
|
| CRiskParameters();
|
| ~CRiskParameters() {}
|
|
|
| // Initialization
|
| bool Initialize();
|
|
|
| // Getters
|
| double GetRiskPerTrade() const { return m_riskPerTrade; }
|
| double GetDailyLossLimit() const { return m_dailyLossLimit; }
|
| double GetMaxPositionSize() const { return m_maxPositionSize; }
|
| double GetMaxLeverage() const { return m_maxLeverage; }
|
| bool UseVolatility() const { return m_useVolatility; }
|
| bool UseCorrelation() const { return m_useCorrelation; }
|
| double GetVolatilityFactor() const { return m_volatilityFactor; }
|
| int GetVolatilityPeriod() const { return m_volatilityPeriod; }
|
| double GetMaxCorrelation() const { return m_maxCorrelation; }
|
| int GetCorrelationPeriod() const { return m_correlationPeriod; }
|
| double GetMinPositionSize() const { return m_minPositionSize; }
|
| double GetMaxLotsPerTrade() const { return m_maxLotsPerTrade; }
|
|
|
| // Setters with validation
|
| bool SetRiskPerTrade(const double risk);
|
| bool SetDailyLossLimit(const double limit);
|
| bool SetMaxPositionSize(const double size);
|
| bool SetMaxLeverage(const double leverage);
|
| void SetUseVolatility(const bool use) { m_useVolatility = use; }
|
| void SetUseCorrelation(const bool use) { m_useCorrelation = use; }
|
| bool SetVolatilityFactor(const double factor);
|
| bool SetVolatilityPeriod(const int period);
|
| bool SetMaxCorrelation(const double correlation);
|
| bool SetCorrelationPeriod(const int period);
|
| bool SetMinPositionSize(const double size);
|
| bool SetMaxLotsPerTrade(const double lots);
|
|
|
| // Validation
|
| static bool IsValidRisk(const double risk);
|
| static bool IsValidLeverage(const double leverage);
|
| static bool IsValidPositionSize(const double size);
|
| static bool IsValidCorrelation(const double correlation);
|
|
|
| private:
|
| // Internal methods
|
| void SetDefaults();
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CRiskParameters::CRiskParameters() :
|
| m_riskPerTrade(1.0), // 1% risk per trade by default
|
| m_dailyLossLimit(5.0), // 5% max daily loss by default
|
| m_maxPositionSize(100.0), // 100 lots max position size by default
|
| m_maxLeverage(100.0), // 1:100 leverage by default
|
| m_useVolatility(true), // Use volatility by default
|
| m_useCorrelation(true), // Use correlation by default
|
| m_volatilityFactor(1.0), // No additional factor by default
|
| m_volatilityPeriod(20), // 20-period lookback for volatility
|
| m_maxCorrelation(0.7), // 70% max correlation
|
| m_correlationPeriod(100), // 100-period lookback for correlation
|
| m_minPositionSize(0.01), // 0.01 lots minimum
|
| m_maxLotsPerTrade(50.0), // 50 lots maximum per trade
|
| m_isInitialized(false)
|
| {
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize with default values |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::Initialize()
|
| {
|
| SetDefaults();
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set default parameters |
|
| //+------------------------------------------------------------------+
|
| void CRiskParameters::SetDefaults()
|
| {
|
| // Load default values from account settings or config file
|
| m_riskPerTrade = 1.0;
|
| m_dailyLossLimit = 5.0;
|
| m_maxPositionSize = 100.0;
|
| m_maxLeverage = AccountInfoInteger(ACCOUNT_LEVERAGE);
|
|
|
| // Advanced settings
|
| m_useVolatility = true;
|
| m_useCorrelation = true;
|
| m_volatilityFactor = 1.0;
|
| m_volatilityPeriod = 20;
|
| m_maxCorrelation = 0.7;
|
| m_correlationPeriod = 100;
|
| m_minPositionSize = 0.01;
|
| m_maxLotsPerTrade = 50.0;
|
|
|
| m_isInitialized = true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set risk per trade with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetRiskPerTrade(const double risk)
|
| {
|
| if (!IsValidRisk(risk))
|
| return false;
|
|
|
| m_riskPerTrade = risk;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set daily loss limit with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetDailyLossLimit(const double limit)
|
| {
|
| if (limit <= 0.0 || limit > 50.0) // Max 50% daily loss
|
| return false;
|
|
|
| m_dailyLossLimit = limit;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set max position size with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetMaxPositionSize(const double size)
|
| {
|
| if (!IsValidPositionSize(size))
|
| return false;
|
|
|
| m_maxPositionSize = size;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set max leverage with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetMaxLeverage(const double leverage)
|
| {
|
| if (!IsValidLeverage(leverage))
|
| return false;
|
|
|
| m_maxLeverage = leverage;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set volatility factor with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetVolatilityFactor(const double factor)
|
| {
|
| if (factor <= 0.0 || factor > 10.0) // Arbitrary upper limit
|
| return false;
|
|
|
| m_volatilityFactor = factor;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set volatility period with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetVolatilityPeriod(const int period)
|
| {
|
| if (period < 5 || period > 200) // Reasonable range for volatility calculation
|
| return false;
|
|
|
| m_volatilityPeriod = period;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set max correlation with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetMaxCorrelation(const double correlation)
|
| {
|
| if (!IsValidCorrelation(correlation))
|
| return false;
|
|
|
| m_maxCorrelation = correlation;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set correlation period with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetCorrelationPeriod(const int period)
|
| {
|
| if (period < 10 || period > 500) // Reasonable range for correlation calculation
|
| return false;
|
|
|
| m_correlationPeriod = period;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set min position size with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetMinPositionSize(const double size)
|
| {
|
| if (size <= 0.0 || size > m_maxLotsPerTrade)
|
| return false;
|
|
|
| m_minPositionSize = size;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Set max lots per trade with validation |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::SetMaxLotsPerTrade(const double lots)
|
| {
|
| if (lots < m_minPositionSize || lots > 1000.0) // Arbitrary upper limit
|
| return false;
|
|
|
| m_maxLotsPerTrade = lots;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Validate risk percentage |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::IsValidRisk(const double risk)
|
| {
|
| return (risk > 0.0 && risk <= 10.0); // Max 10% risk per trade
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Validate leverage |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::IsValidLeverage(const double leverage)
|
| {
|
| return (leverage > 0.0 && leverage <= 1000.0); // Reasonable leverage range
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Validate position size |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::IsValidPositionSize(const double size)
|
| {
|
| return (size > 0.0 && size <= 1000.0); // Reasonable position size range
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Validate correlation value |
|
| //+------------------------------------------------------------------+
|
| bool CRiskParameters::IsValidCorrelation(const double correlation)
|
| {
|
| return (correlation >= 0.0 && correlation <= 1.0); // 0.0 to 1.0 range
|
| }
|
