Diagonal Support Oscillator

[kenorb]

Diagonal Support Oscillator with price proximity involves coding the logic to calculate the oscillator value based on diagonal support lines and their proximity to the price. Below is a simplified version of how you might structure the code:

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Blue
#property indicator_color2 Red

// Indicator parameters
extern int period = 14;         // Period for calculating the oscillator
extern double sensitivity = 10; // Sensitivity to calculate proximity to support

// Indicator buffers
double OscillatorBuffer[];
double SupportLineBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
    // Set buffer properties
    SetIndexStyle(0, DRAW_LINE);
    SetIndexBuffer(0, OscillatorBuffer);
    SetIndexLabel(0, "Oscillator");

    SetIndexStyle(1, DRAW_LINE);
    SetIndexBuffer(1, SupportLineBuffer);
    SetIndexLabel(1, "Support Line");
    SetIndexDrawBegin(1, period); // Avoid drawing the support line initially

    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
    int startIdx = period;
    if (rates_total < period)
        return(0);

    // Calculate diagonal support line
    double diagonalSupportValue = CalculateDiagonalSupportValue(low, period);

    for(int i = startIdx; i >= 0; i--)
    {
       // Calculate proximity of price to support and resistance
        double supportProximity = 1 - MathAbs(close[i] - diagonalSupportValue) / sensitivity;
        double resistanceProximity = 1 - MathAbs(close[i] - diagonalResistanceValue) / sensitivity;

        // Calculate oscillator value
        OscillatorBuffer[i] = (supportProximity - resistanceProximity) * 100; // Scale to 0-100 range
        SupportLineBuffer[i] = diagonalSupportValue; // Set support line value for plotting
        ResistanceLineBuffer[i] = diagonalResistanceValue; // Set resistance line value for plotting
    }

    return(rates_total);
}

//+------------------------------------------------------------------+
//| Function to calculate diagonal support value                     |
//+------------------------------------------------------------------+
double CalculateDiagonalSupportValue(const double &prices[], const int length)
{
    // Implement your logic to calculate diagonal support here
    // You can use regression analysis, trendlines, or other methods
    // For example, a simple linear regression could be used:
    double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
    
    for(int i = 0; i < length; i++)
    {
        sumX += i;
        sumY += prices[i];
        sumXY += i * prices[i];
        sumX2 += i * i;
    }
    
    double slope = (length * sumXY - sumX * sumY) / (length * sumX2 - sumX * sumX);
    double intercept = (sumY - slope * sumX) / length;
    
    return slope * length + intercept;
}

//+------------------------------------------------------------------+
//| Function to calculate diagonal resistance value                  |
//+------------------------------------------------------------------+
double CalculateDiagonalResistanceValue(const double &prices[], const int length)
{
    // Calculate linear regression to find the slope and intercept
    double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;

    for(int i = 0; i < length; i++)
    {
        sumX += i;
        sumY += prices[i];
        sumXY += i * prices[i];
        sumX2 += i * i;
    }

    double slope = (length * sumXY - sumX * sumY) / (length * sumX2 - sumX * sumX);
    double intercept = (sumY - slope * sumX) / length;

    // Calculate resistance line value
    double resistanceValue = slope * length + intercept;

    return resistanceValue;
}