pgupta1646
New member
I am getting a silly Syntax Error in my TOS Script for an Indicator. Can someone help me to pin point the mistake I am making? My script is place
Ruby:
def monthPlus;
def monthMinus;
def monthAdx;
def monthBullishSignal;
def monthBearishSignal;
def monthNarrowRange;
def monthNarrowRangeTest;
def monthBullishZone;
def monthBearishZone;
def monthNeutralZone;
def monthHiDiff;
def monthLoDiff;
def monthPlusDM;
def monthMinusDM;
def monthATR;
if GetAggregationPeriod() <= AggregationPeriod.MONTH {
monthHiDiff = high(period = "Month") - high(period = "Month")[1];
monthLoDiff = low(period = "Month")[1] - low(period = "Month");
monthPlusDM = if monthHiDiff > monthLoDiff and monthHiDiff > 0 then monthHiDiff else 0;
monthMinusDM = if monthLoDiff > monthHiDiff and monthLoDiff > 0 then monthLoDiff else 0;
monthATR = MovingAverage(averageType, TrueRange(high(period = "Month"), close(period = "Month"), low(period = "Month")), length);
monthAdx = DMI(length, averageType).ADX;
monthPlus = 100 * MovingAverage(averageType, monthPlusDM, length) / monthATR;
monthMinus = 100 * MovingAverage(averageType, monthMinusDM, length) / monthATR;
monthBullishSignal = monthPlus crosses above monthMinus;
monthBearishSignal = monthPlus crosses below monthMinus;
monthNarrowRange = if monthMinus > monthPlus then monthMinus - monthPlus else if monthPlus > monthMinus then monthPlus - monthMinus else 0;
monthNarrowRangeTest = monthNarrowRange >= 10;
monthBullishZone = monthPlus > monthMinus and monthNarrowRangeTest;
monthBearishZone = monthPlus < monthMinus and monthNarrowRangeTest;
monthNeutralZone = !monthBullishZone and !monthBearishZone;
} else {
monthPlus = 0;
monthMinus = 0;
monthAdx = 0;
monthPlusDM = 0;
monthMinusDM = 0;
monthBullishSignal = 0;
monthBearishSignal = 0;
monthNarrowRange = 0;
monthNarrowRangeTest = 0;
monthBullishZone = 0;
monthBearishZone = 0;
monthNeutralZone = 0;
monthHiDiff = 0;
monthLoDiff = 0;
monthATR = 0;
}
AddLabel(monthBullishZone or monthBearishZone or monthNeutralZone, "M", if monthBullishZone then Color.GREEN else if monthBearishZone then Color.RED else if monthNeutralZone then Color.YELLOW else Color.GRAY);
def weekPlus;
def weekMinus;
def weekAdx;
def weekBullishSignal;
def weekBearishSignal;
def weekNarrowRange;
def weekNarrowRangeTest;
def weekBullishZone;
def weekBearishZone;
def weekNeutralZone;
def weekHiDiff;
def weekLoDiff;
def weekPlusDM;
def weekMinusDM;
def weekATR;
if GetAggregationPeriod() <= AggregationPeriod.WEEK {
weekHiDiff = high(period = "week") - high(period = "week")[1];
weekLoDiff = low(period = "week")[1] - low(period = "week");
weekPlusDM = if weekHiDiff > weekLoDiff and weekHiDiff > 0 then weekHiDiff else 0;
weekMinusDM = if weekLoDiff > weekHiDiff and weekLoDiff > 0 then weekLoDiff else 0;
weekATR = MovingAverage(averageType, TrueRange(high(period = "week"), close(period = "week"), low(period = "week")), length);
weekAdx = DMI(length, averageType).ADX;
weekPlus = 100 * MovingAverage(averageType, weekPlusDM, length) / weekATR;
weekMinus = 100 * MovingAverage(averageType, weekMinusDM, length) / weekATR;
weekBullishSignal = weekPlus crosses above weekMinus;
weekBearishSignal = weekPlus crosses below weekMinus;
weekNarrowRange = if weekMinus > weekPlus then weekMinus - weekPlus else if weekPlus > weekMinus then weekPlus - weekMinus else 0;
weekNarrowRangeTest = weekNarrowRange >= 10;
weekBullishZone = weekPlus > weekMinus and weekNarrowRangeTest;
weekBearishZone = weekPlus < weekMinus and weekNarrowRangeTest;
weekNeutralZone = !weekBullishZone and !weekBearishZone;
} else {
weekPlus = 0;
weekMinus = 0;
weekAdx = 0;
weekPlusDM = 0;
weekMinusDM = 0;
weekBullishSignal = 0;
weekBearishSignal = 0;
weekNarrowRange = 0;
weekNarrowRangeTest = 0;
weekBullishZone = 0;
weekBearishZone = 0;
weekNeutralZone = 0;
weekHiDiff = 0;
weekLoDiff = 0;
weekATR = 0;
}
AddLabel(weekBullishZone or weekBearishZone or weekNeutralZone, "W", if weekBullishZone then Color.GREEN else if weekBearishZone then Color.RED else if weekNeutralZone then Color.YELLOW else Color.GRAY);
def fourDayPlus;
def fourDayMinus;
def fourDayAdx;
def fourDayBullishSignal;
def fourDayBearishSignal;
def fourDayNarrowRange;
def fourDayNarrowRangeTest;
def fourDayBullishZone;
def fourDayBearishZone;
def fourDayNeutralZone;
def fourDayHiDiff;
def fourDayLoDiff;
def fourDayPlusDM;
def fourDayMinusDM;
def fourDayATR;
if GetAggregationPeriod() <= AggregationPeriod.FOUR_DAYS {
fourDayHiDiff = high(period = "4 Days") - high(period = "4 Days")[1];
fourDayLoDiff = low(period = "4 Days")[1] - low(period = "4 Days");
fourDayPlusDM = if fourDayHiDiff > fourDayLoDiff and fourDayHiDiff > 0 then fourDayHiDiff else 0;
fourDayMinusDM = if fourDayLoDiff > fourDayHiDiff and fourDayLoDiff > 0 then fourDayLoDiff else 0;
fourDayATR = MovingAverage(averageType, TrueRange(high(period = "4 Days"), close(period = "4 Days"), low(period = "4 Days")), length);
fourDayAdx = DMI(length, averageType).ADX;
fourDayPlus = 100 * MovingAverage(averageType, fourDayPlusDM, length) / fourDayATR;
fourDayMinus = 100 * MovingAverage(averageType, fourDayMinusDM, length) / fourDayATR;
fourDayBullishSignal = fourDayPlus crosses above fourDayMinus;
fourDayBearishSignal = fourDayPlus crosses below fourDayMinus;
fourDayNarrowRange = if fourDayMinus > fourDayPlus then fourDayMinus - fourDayPlus else if fourDayPlus > fourDayMinus then fourDayPlus - fourDayMinus else 0;
fourDayNarrowRangeTest = fourDayNarrowRange >= 10;
fourDayBullishZone = fourDayPlus > fourDayMinus and fourDayNarrowRangeTest;
fourDayBearishZone = fourDayPlus < fourDayMinus and fourDayNarrowRangeTest;
fourDayNeutralZone = !fourDayBullishZone and !fourDayBearishZone;
} else {
fourDayPlus = 0;
fourDayMinus = 0;
fourDayAdx = 0;
fourDayPlusDM = 0;
fourDayMinusDM = 0;
fourDayBullishSignal = 0;
fourDayBearishSignal = 0;
fourDayNarrowRange = 0;
fourDayNarrowRangeTest = 0;
fourDayBullishZone = 0;
fourDayBearishZone = 0;
fourDayNeutralZone = 0;
fourDayHiDiff = 0;
fourDayLoDiff = 0;
fourDayATR = 0;
}
AddLabel(fourDayBullishZone or fourDayBearishZone or fourDayNeutralZone, "4D", if fourDayBullishZone then Color.GREEN else if fourDayBearishZone then Color.RED else if fourDayNeutralZone then Color.YELLOW else Color.GRAY);
def threeDayPlus;
def threeDayMinus;
def threeDayAdx;
def threeDayBullishSignal;
def threeDayBearishSignal;
def threeDayNarrowRange;
def threeDayNarrowRangeTest;
def threeDayBullishZone;
def threeDayBearishZone;
def threeDayNeutralZone;
def threeDayHiDiff;
def threeDayLoDiff;
def threeDayPlusDM;
def threeDayMinusDM;
def threeDayATR;
if GetAggregationPeriod() <= AggregationPeriod.THREE_DAYS {
threeDayHiDiff = high(period = "3 Days") - high(period = "3 Days")[1];
threeDayLoDiff = low(period = "3 Days")[1] - low(period = "3 Days");
threeDayPlusDM = if threeDayHiDiff > threeDayLoDiff and threeDayHiDiff > 0 then threeDayHiDiff else 0;
threeDayMinusDM = if threeDayLoDiff > threeDayHiDiff and threeDayLoDiff > 0 then threeDayLoDiff else 0;
threeDayATR = MovingAverage(averageType, TrueRange(high(period = "3 Days"), close(period = "3 Days"), low(period = "3 Days")), length);
threeDayAdx = DMI(length, averageType).ADX;
threeDayPlus = 100 * MovingAverage(averageType, threeDayPlusDM, length) / threeDayATR;
threeDayMinus = 100 * MovingAverage(averageType, threeDayMinusDM, length) / threeDayATR;
threeDayBullishSignal = threeDayPlus crosses above threeDayMinus;
threeDayBearishSignal = threeDayPlus crosses below threeDayMinus;
threeDayNarrowRange = if threeDayMinus > threeDayPlus then threeDayMinus - threeDayPlus else if threeDayPlus > threeDayMinus then threeDayPlus - threeDayMinus else 0;
threeDayNarrowRangeTest = threeDayNarrowRange >= 10;
threeDayBullishZone = threeDayPlus > threeDayMinus and threeDayNarrowRangeTest;
threeDayBearishZone = threeDayPlus < threeDayMinus and threeDayNarrowRangeTest;
threeDayNeutralZone = !threeDayBullishZone and !threeDayBearishZone;
} else {
threeDayPlus = 0;
threeDayMinus = 0;
threeDayAdx = 0;
threeDayPlusDM = 0;
threeDayMinusDM = 0;
threeDayBullishSignal = 0;
threeDayBearishSignal = 0;
threeDayNarrowRange = 0;
threeDayNarrowRangeTest = 0;
threeDayBullishZone = 0;
threeDayBearishZone = 0;
threeDayNeutralZone = 0;
threeDayHiDiff = 0;
threeDayLoDiff = 0;
threeDayATR = 0;
}
AddLabel(threeDayBullishZone or threeDayBearishZone or threeDayNeutralZone, "3D", if threeDayBullishZone then Color.GREEN else if threeDayBearishZone then Color.RED else if threeDayNeutralZone then Color.YELLOW else Color.GRAY);
def twoDayPlus;
def twoDayMinus;
def twoDayAdx;
def twoDayBullishSignal;
def twoDayBearishSignal;
def twoDayNarrowRange;
def twoDayNarrowRangeTest;
def twoDayBullishZone;
def twoDayBearishZone;
def twoDayNeutralZone;
def twoDayHiDiff;
def twoDayLoDiff;
def twoDayPlusDM;
def twoDayMinusDM;
def twoDayATR;
if GetAggregationPeriod() <= AggregationPeriod.TWO_DAYS {
twoDayHiDiff = high(period = "2 Days") - high(period = "2 Days")[1];
twoDayLoDiff = low(period = "2 Days")[1] - low(period = "2 Days");
twoDayPlusDM = if twoDayHiDiff > twoDayLoDiff and twoDayHiDiff > 0 then twoDayHiDiff else 0;
twoDayMinusDM = if twoDayLoDiff > twoDayHiDiff and twoDayLoDiff > 0 then twoDayLoDiff else 0;
twoDayATR = MovingAverage(averageType, TrueRange(high(period = "2 Days"), close(period = "2 Days"), low(period = "2 Days")), length);
twoDayAdx = DMI(length, averageType).ADX;
twoDayPlus = 100 * MovingAverage(averageType, twoDayPlusDM, length) / twoDayATR;
twoDayMinus = 100 * MovingAverage(averageType, twoDayMinusDM, length) / twoDayATR;
twoDayBullishSignal = twoDayPlus crosses above twoDayMinus;
twoDayBearishSignal = twoDayPlus crosses below twoDayMinus;
twoDayNarrowRange = if twoDayMinus > twoDayPlus then twoDayMinus - twoDayPlus else if twoDayPlus > twoDayMinus then twoDayPlus - twoDayMinus else 0;
twoDayNarrowRangeTest = twoDayNarrowRange >= 10;
twoDayBullishZone = twoDayPlus > twoDayMinus and twoDayNarrowRangeTest;
twoDayBearishZone = twoDayPlus < twoDayMinus and twoDayNarrowRangeTest;
twoDayNeutralZone = !twoDayBullishZone and !twoDayBearishZone;
} else {
twoDayPlus = 0;
twoDayMinus = 0;
twoDayAdx = 0;
twoDayPlusDM = 0;
twoDayMinusDM = 0;
twoDayBullishSignal = 0;
twoDayBearishSignal = 0;
twoDayNarrowRange = 0;
twoDayNarrowRangeTest = 0;
twoDayBullishZone = 0;
twoDayBearishZone = 0;
twoDayNeutralZone = 0;
twoDayHiDiff = 0;
twoDayLoDiff = 0;
twoDayATR = 0;
}
AddLabel(twoDayBullishZone or twoDayBearishZone or twoDayNeutralZone, "2D", if twoDayBullishZone then Color.GREEN else if twoDayBearishZone then Color.RED else if twoDayNeutralZone then Color.YELLOW else Color.GRAY);
def DayPlus;
def DayMinus;
def DayAdx;
def DayBullishSignal;
def DayBearishSignal;
def DayNarrowRange;
def DayNarrowRangeTest;
def DayBullishZone;
def DayBearishZone;
def DayNeutralZone;
def DayHiDiff;
def DayLoDiff;
def DayPlusDM;
def DayMinusDM;
def DayATR;
if GetAggregationPeriod() <= AggregationPeriod.DAY {
DayHiDiff = high(period = "Day") - high(period = "Day")[1];
DayLoDiff = low(period = "Day")[1] - low(period = "Day");
DayPlusDM = if DayHiDiff > DayLoDiff and DayHiDiff > 0 then DayHiDiff else 0;
DayMinusDM = if DayLoDiff > DayHiDiff and DayLoDiff > 0 then DayLoDiff else 0;
DayATR = MovingAverage(averageType, TrueRange(high(period = "Day"), close(period = "Day"), low(period = "Day")), length);
DayAdx = DMI(length, averageType).ADX;
DayPlus = 100 * MovingAverage(averageType, DayPlusDM, length) / DayATR;
DayMinus = 100 * MovingAverage(averageType, DayMinusDM, length) / DayATR;
DayBullishSignal = DayPlus crosses above DayMinus;
DayBearishSignal = DayPlus crosses below DayMinus;
DayNarrowRange = if DayMinus > DayPlus then DayMinus - DayPlus else if DayPlus > DayMinus then DayPlus - DayMinus else 0;
DayNarrowRangeTest = DayNarrowRange >= 10;
DayBullishZone = DayPlus > DayMinus and DayNarrowRangeTest;
DayBearishZone = DayPlus < DayMinus and DayNarrowRangeTest;
DayNeutralZone = !DayBullishZone and !DayBearishZone;
} else {
DayPlus = 0;
DayMinus = 0;
DayAdx = 0;
DayPlusDM = 0;
DayMinusDM = 0;
DayBullishSignal = 0;
DayBearishSignal = 0;
DayNarrowRange = 0;
DayNarrowRangeTest = 0;
DayBullishZone = 0;
DayBearishZone = 0;
DayNeutralZone = 0;
DayHiDiff = 0;
DayLoDiff = 0;
DayATR = 0;
}
AddLabel(DayBullishZone or DayBearishZone or DayNeutralZone, "D", if DayBullishZone then Color.GREEN else if DayBearishZone then Color.RED else if DayNeutralZone then Color.YELLOW else Color.GRAY);
def fourHoursPlus;
def fourHoursMinus;
def fourHoursAdx;
def fourHoursBullishSignal;
def fourHoursBearishSignal;
def fourHoursNarrowRange;
def fourHoursNarrowRangeTest;
def fourHoursBullishZone;
def fourHoursBearishZone;
def fourHoursNeutralZone;
def fourHoursHiDiff;
def fourHoursLoDiff;
def fourHoursPlusDM;
def fourHoursMinusDM;
def fourHoursATR;
if GetAggregationPeriod() <= AggregationPeriod.FOUR_HOURS {
fourHoursHiDiff = high(period = "4 hours") - high(period = "4 hours")[1];
fourHoursLoDiff = low(period = "4 hours")[1] - low(period = "4 hours");
fourHoursPlusDM = if fourHoursHiDiff > fourHoursLoDiff and fourHoursHiDiff > 0 then fourHoursHiDiff else 0;
fourHoursMinusDM = if fourHoursLoDiff > fourHoursHiDiff and fourHoursLoDiff > 0 then fourHoursLoDiff else 0;
fourHoursATR = MovingAverage(averageType, TrueRange(high(period = "4 hours"), close(period = "4 hours"), low(period = "4 hours")), length);
fourHoursAdx = DMI(length, averageType).ADX;
fourHoursPlus = 100 * MovingAverage(averageType, fourHoursPlusDM, length) / fourHoursATR;
fourHoursMinus = 100 * MovingAverage(averageType, fourHoursMinusDM, length) / fourHoursATR;
fourHoursBullishSignal = fourHoursPlus crosses above fourHoursMinus;
fourHoursBearishSignal = fourHoursPlus crosses below fourHoursMinus;
fourHoursNarrowRange = if fourHoursMinus > fourHoursPlus then fourHoursMinus - fourHoursPlus else if fourHoursPlus > fourHoursMinus then fourHoursPlus - fourHoursMinus else 0;
fourHoursNarrowRangeTest = fourHoursNarrowRange >= 10;
fourHoursBullishZone = fourHoursPlus > fourHoursMinus and fourHoursNarrowRangeTest;
fourHoursBearishZone = fourHoursPlus < fourHoursMinus and fourHoursNarrowRangeTest;
fourHoursNeutralZone = !fourHoursBullishZone and !fourHoursBearishZone;
} else {
fourHoursPlus = 0;
fourHoursMinus = 0;
fourHoursAdx = 0;
fourHoursPlusDM = 0;
fourHoursMinusDM = 0;
fourHoursBullishSignal = 0;
fourHoursBearishSignal = 0;
fourHoursNarrowRange = 0;
fourHoursNarrowRangeTest = 0;
fourHoursBullishZone = 0;
fourHoursBearishZone = 0;
fourHoursNeutralZone = 0;
fourHoursHiDiff = 0;
fourHoursLoDiff = 0;
fourHoursATR = 0;
}
AddLabel(fourHoursBullishZone or fourHoursBearishZone or fourHoursNeutralZone, "4H", if fourHoursBullishZone then Color.GREEN else if fourHoursBearishZone then Color.RED else if fourHoursNeutralZone then Color.YELLOW else Color.GRAY);
def twoHoursPlus;
def twoHoursMinus;
def twoHoursAdx;
def twoHoursBullishSignal;
def twoHoursBearishSignal;
def twoHoursNarrowRange;
def twoHoursNarrowRangeTest;
def twoHoursBullishZone;
def twoHoursBearishZone;
def twoHoursNeutralZone;
def twoHoursHiDiff;
def twoHoursLoDiff;
def twoHoursPlusDM;
def twoHoursMinusDM;
def twoHoursATR;
if GetAggregationPeriod() <= AggregationPeriod.TWO_HOURS {
twoHoursHiDiff = high(period = "2 hours") - high(period = "2 hours")[1];
twoHoursLoDiff = low(period = "2 hours")[1] - low(period = "2 hours");
twoHoursPlusDM = if twoHoursHiDiff > twoHoursLoDiff and twoHoursHiDiff > 0 then twoHoursHiDiff else 0;
twoHoursMinusDM = if twoHoursLoDiff > twoHoursHiDiff and twoHoursLoDiff > 0 then twoHoursLoDiff else 0;
twoHoursATR = MovingAverage(averageType, TrueRange(high(period = "2 hours"), close(period = "2 hours"), low(period = "2 hours")), length);
twoHoursAdx = DMI(length, averageType).ADX;
twoHoursPlus = 100 * MovingAverage(averageType, twoHoursPlusDM, length) / twoHoursATR;
twoHoursMinus = 100 * MovingAverage(averageType, twoHoursMinusDM, length) / twoHoursATR;
twoHoursBullishSignal = twoHoursPlus crosses above twoHoursMinus;
twoHoursBearishSignal = twoHoursPlus crosses below twoHoursMinus;
twoHoursNarrowRange = if twoHoursMinus > twoHoursPlus then twoHoursMinus - twoHoursPlus else if twoHoursPlus > twoHoursMinus then twoHoursPlus - twoHoursMinus else 0;
twoHoursNarrowRangeTest = twoHoursNarrowRange >= 10;
twoHoursBullishZone = twoHoursPlus > twoHoursMinus and twoHoursNarrowRangeTest;
twoHoursBearishZone = twoHoursPlus < twoHoursMinus and twoHoursNarrowRangeTest;
twoHoursNeutralZone = !twoHoursBullishZone and !twoHoursBearishZone;
} else {
twoHoursPlus = 0;
twoHoursMinus = 0;
twoHoursAdx = 0;
twoHoursPlusDM = 0;
twoHoursMinusDM = 0;
twoHoursBullishSignal = 0;
twoHoursBearishSignal = 0;
twoHoursNarrowRange = 0;
twoHoursNarrowRangeTest = 0;
twoHoursBullishZone = 0;
twoHoursBearishZone = 0;
twoHoursNeutralZone = 0;
twoHoursHiDiff = 0;
twoHoursLoDiff = 0;
twoHoursATR = 0;
}
AddLabel(twoHoursBullishZone or twoHoursBearishZone or twoHoursNeutralZone, "2H", if twoHoursBullishZone then Color.GREEN else if twoHoursBearishZone then Color.RED else if twoHoursNeutralZone then Color.YELLOW else Color.GRAY);
def HourPlus;
def HourMinus;
def HourAdx;
def HourBullishSignal;
def HourBearishSignal;
def HourNarrowRange;
def HourNarrowRangeTest;
def HourBullishZone;
def HourBearishZone;
def HourNeutralZone;
def HourHiDiff;
def HourLoDiff;
def HourPlusDM;
def HourMinusDM;
def HourATR;
if GetAggregationPeriod() <= AggregationPeriod.HOUR {
HourHiDiff = high(period = "1 Hour") - high(period = "1 Hour")[1];
HourLoDiff = low(period = "1 Hour")[1] - low(period = "1 Hour");
HourPlusDM = if HourHiDiff > HourLoDiff and HourHiDiff > 0 then HourHiDiff else 0;
HourMinusDM = if HourLoDiff > HourHiDiff and HourLoDiff > 0 then HourLoDiff else 0;
HourATR = MovingAverage(averageType, TrueRange(high(period = "1 Hour"), close(period = "1 Hour"), low(period = "1 Hour")), length);
HourAdx = DMI(length, averageType).ADX;
HourPlus = 100 * MovingAverage(averageType, HourPlusDM, length) / HourATR;
HourMinus = 100 * MovingAverage(averageType, HourMinusDM, length) / HourATR;
HourBullishSignal = HourPlus crosses above HourMinus;
HourBearishSignal = HourPlus crosses below HourMinus;
HourNarrowRange = if HourMinus > HourPlus then HourMinus - HourPlus else if HourPlus > HourMinus then HourPlus - HourMinus else 0;
HourNarrowRangeTest = HourNarrowRange >= 10;
HourBullishZone = HourPlus > HourMinus and HourNarrowRangeTest;
HourBearishZone = HourPlus < HourMinus and HourNarrowRangeTest;
HourNeutralZone = !HourBullishZone and !HourBearishZone;
} else {
HourPlus = 0;
HourMinus = 0;
HourAdx = 0;
HourPlusDM = 0;
HourMinusDM = 0;
HourBullishSignal = 0;
HourBearishSignal = 0;
HourNarrowRange = 0;
HourNarrowRangeTest = 0;
HourBullishZone = 0;
HourBearishZone = 0;
HourNeutralZone = 0;
HourHiDiff = 0;
HourLoDiff = 0;
HourATR = 0;
}
AddLabel(HourBullishZone or HourBearishZone or HourNeutralZone, "H", if HourBullishZone then Color.GREEN else if HourBearishZone then Color.RED else if HourNeutralZone then Color.YELLOW else Color.GRAY);
def thirtyMinutesPlus;
def thirtyMinutesMinus;
def thirtyMinutesAdx;
def thirtyMinutesBullishSignal;
def thirtyMinutesBearishSignal;
def thirtyMinutesNarrowRange;
def thirtyMinutesNarrowRangeTest;
def thirtyMinutesBullishZone;
def thirtyMinutesBearishZone;
def thirtyMinutesNeutralZone;
def thirtyMinutesHiDiff;
def thirtyMinutesLoDiff;
def thirtyMinutesPlusDM;
def thirtyMinutesMinusDM;
def thirtyMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.THIRTY_MIN {
thirtyMinutesHiDiff = high(period = "30 Min") - high(period = "30 Min")[1];
thirtyMinutesLoDiff = low(period = "30 Min")[1] - low(period = "30 Min");
thirtyMinutesPlusDM = if thirtyMinutesHiDiff > thirtyMinutesLoDiff and thirtyMinutesHiDiff > 0 then thirtyMinutesHiDiff else 0;
thirtyMinutesMinusDM = if thirtyMinutesLoDiff > thirtyMinutesHiDiff and thirtyMinutesLoDiff > 0 then thirtyMinutesLoDiff else 0;
thirtyMinutesATR = MovingAverage(averageType, TrueRange(high(period = "30 Min"), close(period = "30 Min"), low(period = "30 Min")), length);
thirtyMinutesAdx = DMI(length, averageType).ADX;
thirtyMinutesPlus = 100 * MovingAverage(averageType, thirtyMinutesPlusDM, length) / thirtyMinutesATR;
thirtyMinutesMinus = 100 * MovingAverage(averageType, thirtyMinutesMinusDM, length) / thirtyMinutesATR;
thirtyMinutesBullishSignal = thirtyMinutesPlus crosses above thirtyMinutesMinus;
thirtyMinutesBearishSignal = thirtyMinutesPlus crosses below thirtyMinutesMinus;
thirtyMinutesNarrowRange = if thirtyMinutesMinus > thirtyMinutesPlus then thirtyMinutesMinus - thirtyMinutesPlus else if thirtyMinutesPlus > thirtyMinutesMinus then thirtyMinutesPlus - thirtyMinutesMinus else 0;
thirtyMinutesNarrowRangeTest = thirtyMinutesNarrowRange >= 10;
thirtyMinutesBullishZone = thirtyMinutesPlus > thirtyMinutesMinus and thirtyMinutesNarrowRangeTest;
thirtyMinutesBearishZone = thirtyMinutesPlus < thirtyMinutesMinus and thirtyMinutesNarrowRangeTest;
thirtyMinutesNeutralZone = !thirtyMinutesBullishZone and !thirtyMinutesBearishZone;
} else {
thirtyMinutesPlus = 0;
thirtyMinutesMinus = 0;
thirtyMinutesAdx = 0;
thirtyMinutesPlusDM = 0;
thirtyMinutesMinusDM = 0;
thirtyMinutesBullishSignal = 0;
thirtyMinutesBearishSignal = 0;
thirtyMinutesNarrowRange = 0;
thirtyMinutesNarrowRangeTest = 0;
thirtyMinutesBullishZone = 0;
thirtyMinutesBearishZone = 0;
thirtyMinutesNeutralZone = 0;
thirtyMinutesHiDiff = 0;
thirtyMinutesLoDiff = 0;
thirtyMinutesATR = 0;
}
AddLabel(thirtyMinutesBullishZone or thirtyMinutesBearishZone or thirtyMinutesNeutralZone, "30m", if thirtyMinutesBullishZone then Color.GREEN else if thirtyMinutesBearishZone then Color.RED else if thirtyMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def fifteenMinutesPlus;
def fifteenMinutesMinus;
def fifteenMinutesAdx;
def fifteenMinutesBullishSignal;
def fifteenMinutesBearishSignal;
def fifteenMinutesNarrowRange;
def fifteenMinutesNarrowRangeTest;
def fifteenMinutesBullishZone;
def fifteenMinutesBearishZone;
def fifteenMinutesNeutralZone;
def fifteenMinutesHiDiff;
def fifteenMinutesLoDiff;
def fifteenMinutesPlusDM;
def fifteenMinutesMinusDM;
def fifteenMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.FIFTEEN_MIN {
fifteenMinutesHiDiff = high(period = "15 Min") - high(period = "15 Min")[1];
fifteenMinutesLoDiff = low(period = "15 Min")[1] - low(period = "15 Min");
fifteenMinutesPlusDM = if fifteenMinutesHiDiff > fifteenMinutesLoDiff and fifteenMinutesHiDiff > 0 then fifteenMinutesHiDiff else 0;
fifteenMinutesMinusDM = if fifteenMinutesLoDiff > fifteenMinutesHiDiff and fifteenMinutesLoDiff > 0 then fifteenMinutesLoDiff else 0;
fifteenMinutesATR = MovingAverage(averageType, TrueRange(high(period = "15 Min"), close(period = "15 Min"), low(period = "15 Min")), length);
fifteenMinutesAdx = DMI(length, averageType).ADX;
fifteenMinutesPlus = 100 * MovingAverage(averageType, fifteenMinutesPlusDM, length) / fifteenMinutesATR;
fifteenMinutesMinus = 100 * MovingAverage(averageType, fifteenMinutesMinusDM, length) / fifteenMinutesATR;
fifteenMinutesBullishSignal = fifteenMinutesPlus crosses above fifteenMinutesMinus;
fifteenMinutesBearishSignal = fifteenMinutesPlus crosses below fifteenMinutesMinus;
fifteenMinutesNarrowRange = if fifteenMinutesMinus > fifteenMinutesPlus then fifteenMinutesMinus - fifteenMinutesPlus else if fifteenMinutesPlus > fifteenMinutesMinus then fifteenMinutesPlus - fifteenMinutesMinus else 0;
fifteenMinutesNarrowRangeTest = fifteenMinutesNarrowRange >= 10;
fifteenMinutesBullishZone = fifteenMinutesPlus > fifteenMinutesMinus and fifteenMinutesNarrowRangeTest;
fifteenMinutesBearishZone = fifteenMinutesPlus < fifteenMinutesMinus and fifteenMinutesNarrowRangeTest;
fifteenMinutesNeutralZone = !fifteenMinutesBullishZone and !fifteenMinutesBearishZone;
} else {
fifteenMinutesPlus = 0;
fifteenMinutesMinus = 0;
fifteenMinutesAdx = 0;
fifteenMinutesPlusDM = 0;
fifteenMinutesMinusDM = 0;
fifteenMinutesBullishSignal = 0;
fifteenMinutesBearishSignal = 0;
fifteenMinutesNarrowRange = 0;
fifteenMinutesNarrowRangeTest = 0;
fifteenMinutesBullishZone = 0;
fifteenMinutesBearishZone = 0;
fifteenMinutesNeutralZone = 0;
fifteenMinutesHiDiff = 0;
fifteenMinutesLoDiff = 0;
fifteenMinutesATR = 0;
}
AddLabel(fifteenMinutesBullishZone or fifteenMinutesBearishZone or fifteenMinutesNeutralZone, "15m", if fifteenMinutesBullishZone then Color.GREEN else if fifteenMinutesBearishZone then Color.RED else if fifteenMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def tenMinutesPlus;
def tenMinutesMinus;
def tenMinutesAdx;
def tenMinutesBullishSignal;
def tenMinutesBearishSignal;
def tenMinutesNarrowRange;
def tenMinutesNarrowRangeTest;
def tenMinutesBullishZone;
def tenMinutesBearishZone;
def tenMinutesNeutralZone;
def tenMinutesHiDiff;
def tenMinutesLoDiff;
def tenMinutesPlusDM;
def tenMinutesMinusDM;
def tenMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.TEN_MIN {
tenMinutesHiDiff = high(period = "10 Min") - high(period = "10 Min")[1];
tenMinutesLoDiff = low(period = "10 Min")[1] - low(period = "10 Min");
tenMinutesPlusDM = if tenMinutesHiDiff > tenMinutesLoDiff and tenMinutesHiDiff > 0 then tenMinutesHiDiff else 0;
tenMinutesMinusDM = if tenMinutesLoDiff > tenMinutesHiDiff and tenMinutesLoDiff > 0 then tenMinutesLoDiff else 0;
tenMinutesATR = MovingAverage(averageType, TrueRange(high(period = "10 Min"), close(period = "10 Min"), low(period = "10 Min")), length);
tenMinutesAdx = DMI(length, averageType).ADX;
tenMinutesPlus = 100 * MovingAverage(averageType, tenMinutesPlusDM, length) / tenMinutesATR;
tenMinutesMinus = 100 * MovingAverage(averageType, tenMinutesMinusDM, length) / tenMinutesATR;
tenMinutesBullishSignal = tenMinutesPlus crosses above tenMinutesMinus;
tenMinutesBearishSignal = tenMinutesPlus crosses below tenMinutesMinus;
tenMinutesNarrowRange = if tenMinutesMinus > tenMinutesPlus then tenMinutesMinus - tenMinutesPlus else if tenMinutesPlus > tenMinutesMinus then tenMinutesPlus - tenMinutesMinus else 0;
tenMinutesNarrowRangeTest = tenMinutesNarrowRange >= 10;
tenMinutesBullishZone = tenMinutesPlus > tenMinutesMinus and tenMinutesNarrowRangeTest;
tenMinutesBearishZone = tenMinutesPlus < tenMinutesMinus and tenMinutesNarrowRangeTest;
tenMinutesNeutralZone = !tenMinutesBullishZone and !tenMinutesBearishZone;
} else {
tenMinutesPlus = 0;
tenMinutesMinus = 0;
tenMinutesAdx = 0;
tenMinutesPlusDM = 0;
tenMinutesMinusDM = 0;
tenMinutesBullishSignal = 0;
tenMinutesBearishSignal = 0;
tenMinutesNarrowRange = 0;
tenMinutesNarrowRangeTest = 0;
tenMinutesBullishZone = 0;
tenMinutesBearishZone = 0;
tenMinutesNeutralZone = 0;
tenMinutesHiDiff = 0;
tenMinutesLoDiff = 0;
tenMinutesATR = 0;
}
AddLabel(tenMinutesBullishZone or tenMinutesBearishZone or tenMinutesNeutralZone, "10m", if tenMinutesBullishZone then Color.GREEN else if tenMinutesBearishZone then Color.RED else if tenMinutesNeutralZone then Color.YELLOW else Color.GRAY);
AssignPriceColor(if monthNeutralZone then Color.YELLOW else if monthBullishZone then Color.GREEN else if monthBearishZone then Color.RED else Color.YELLOW);
def fiveMinutesPlus;
def fiveMinutesMinus;
def fiveMinutesAdx;
def fiveMinutesBullishSignal;
def fiveMinutesBearishSignal;
def fiveMinutesNarrowRange;
def fiveMinutesNarrowRangeTest;
def fiveMinutesBullishZone;
def fiveMinutesBearishZone;
def fiveMinutesNeutralZone;
def fiveMinutesHiDiff;
def fiveMinutesLoDiff;
def fiveMinutesPlusDM;
def fiveMinutesMinusDM;
def fiveMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.FIVE_MIN {
fiveMinutesHiDiff = high(period = "5 Min") - high(period = "5 Min")[1];
fiveMinutesLoDiff = low(period = "5 Min")[1] - low(period = "5 Min");
fiveMinutesPlusDM = if fiveMinutesHiDiff > fiveMinutesLoDiff and fiveMinutesHiDiff > 0 then fiveMinutesHiDiff else 0;
fiveMinutesMinusDM = if fiveMinutesLoDiff > fiveMinutesHiDiff and fiveMinutesLoDiff > 0 then fiveMinutesLoDiff else 0;
fiveMinutesATR = MovingAverage(averageType, TrueRange(high(period = "5 Min"), close(period = "5 Min"), low(period = "5 Min")), length);
fiveMinutesAdx = DMI(length, averageType).ADX;
fiveMinutesPlus = 100 * MovingAverage(averageType, fiveMinutesPlusDM, length) / fiveMinutesATR;
fiveMinutesMinus = 100 * MovingAverage(averageType, fiveMinutesMinusDM, length) / fiveMinutesATR;
fiveMinutesBullishSignal = fiveMinutesPlus crosses above fiveMinutesMinus;
fiveMinutesBearishSignal = fiveMinutesPlus crosses below fiveMinutesMinus;
fiveMinutesNarrowRange = if fiveMinutesMinus > fiveMinutesPlus then fiveMinutesMinus - fiveMinutesPlus else if fiveMinutesPlus > fiveMinutesMinus then fiveMinutesPlus - fiveMinutesMinus else 0;
fiveMinutesNarrowRangeTest = fiveMinutesNarrowRange >= 10;
fiveMinutesBullishZone = fiveMinutesPlus > fiveMinutesMinus and fiveMinutesNarrowRangeTest;
fiveMinutesBearishZone = fiveMinutesPlus < fiveMinutesMinus and fiveMinutesNarrowRangeTest;
fiveMinutesNeutralZone = !fiveMinutesBullishZone and !fiveMinutesBearishZone;
} else {
fiveMinutesPlus = 0;
fiveMinutesMinus = 0;
fiveMinutesAdx = 0;
fiveMinutesPlusDM = 0;
fiveMinutesMinusDM = 0;
fiveMinutesBullishSignal = 0;
fiveMinutesBearishSignal = 0;
fiveMinutesNarrowRange = 0;
fiveMinutesNarrowRangeTest = 0;
fiveMinutesBullishZone = 0;
fiveMinutesBearishZone = 0;
fiveMinutesNeutralZone = 0;
fiveMinutesHiDiff = 0;
fiveMinutesLoDiff = 0;
fiveMinutesATR = 0;
}
AddLabel(fiveMinutesBullishZone or fiveMinutesBearishZone or fiveMinutesNeutralZone, "5m", if fiveMinutesBullishZone then Color.GREEN else if fiveMinutesBearishZone then Color.RED else if fiveMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def fourMinutesPlus;
def fourMinutesMinus;
def fourMinutesAdx;
def fourMinutesBullishSignal;
def fourMinutesBearishSignal;
def fourMinutesNarrowRange;
def fourMinutesNarrowRangeTest;
def fourMinutesBullishZone;
def fourMinutesBearishZone;
def fourMinutesNeutralZone;
def fourMinutesHiDiff;
def fourMinutesLoDiff;
def fourMinutesPlusDM;
def fourMinutesMinusDM;
def fourMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.FOUR_MIN {
fourMinutesHiDiff = high(period = "4 Min") - high(period = "4 Min")[1];
fourMinutesLoDiff = low(period = "4 Min")[1] - low(period = "4 Min");
fourMinutesPlusDM = if fourMinutesHiDiff > fourMinutesLoDiff and fourMinutesHiDiff > 0 then fourMinutesHiDiff else 0;
fourMinutesMinusDM = if fourMinutesLoDiff > fourMinutesHiDiff and fourMinutesLoDiff > 0 then fourMinutesLoDiff else 0;
fourMinutesATR = MovingAverage(averageType, TrueRange(high(period = "4 Min"), close(period = "4 Min"), low(period = "4 Min")), length);
fourMinutesAdx = DMI(length, averageType).ADX;
fourMinutesPlus = 100 * MovingAverage(averageType, fourMinutesPlusDM, length) / fourMinutesATR;
fourMinutesMinus = 100 * MovingAverage(averageType, fourMinutesMinusDM, length) / fourMinutesATR;
fourMinutesBullishSignal = fourMinutesPlus crosses above fourMinutesMinus;
fourMinutesBearishSignal = fourMinutesPlus crosses below fourMinutesMinus;
fourMinutesNarrowRange = if fourMinutesMinus > fourMinutesPlus then fourMinutesMinus - fourMinutesPlus else if fourMinutesPlus > fourMinutesMinus then fourMinutesPlus - fourMinutesMinus else 0;
fourMinutesNarrowRangeTest = fourMinutesNarrowRange >= 10;
fourMinutesBullishZone = fourMinutesPlus > fourMinutesMinus and fourMinutesNarrowRangeTest;
fourMinutesBearishZone = fourMinutesPlus < fourMinutesMinus and fourMinutesNarrowRangeTest;
fourMinutesNeutralZone = !fourMinutesBullishZone and !fourMinutesBearishZone;
} else {
fourMinutesPlus = 0;
fourMinutesMinus = 0;
fourMinutesAdx = 0;
fourMinutesPlusDM = 0;
fourMinutesMinusDM = 0;
fourMinutesBullishSignal = 0;
fourMinutesBearishSignal = 0;
fourMinutesNarrowRange = 0;
fourMinutesNarrowRangeTest = 0;
fourMinutesBullishZone = 0;
fourMinutesBearishZone = 0;
fourMinutesNeutralZone = 0;
fourMinutesHiDiff = 0;
fourMinutesLoDiff = 0;
fourMinutesATR = 0;
}
AddLabel(fourMinutesBullishZone or fourMinutesBearishZone or fourMinutesNeutralZone, "4m", if fourMinutesBullishZone then Color.GREEN else if fourMinutesBearishZone then Color.RED else if fourMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def threeMinutesPlus;
def threeMinutesMinus;
def threeMinutesAdx;
def threeMinutesBullishSignal;
def threeMinutesBearishSignal;
def threeMinutesNarrowRange;
def threeMinutesNarrowRangeTest;
def threeMinutesBullishZone;
def threeMinutesBearishZone;
def threeMinutesNeutralZone;
def threeMinutesHiDiff;
def threeMinutesLoDiff;
def threeMinutesPlusDM;
def threeMinutesMinusDM;
def threeMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.THREE_MIN {
threeMinutesHiDiff = high(period = "3 Min") - high(period = "3 Min")[1];
threeMinutesLoDiff = low(period = "3 Min")[1] - low(period = "3 Min");
threeMinutesPlusDM = if threeMinutesHiDiff > threeMinutesLoDiff and threeMinutesHiDiff > 0 then threeMinutesHiDiff else 0;
threeMinutesMinusDM = if threeMinutesLoDiff > threeMinutesHiDiff and threeMinutesLoDiff > 0 then threeMinutesLoDiff else 0;
threeMinutesATR = MovingAverage(averageType, TrueRange(high(period = "3 Min"), close(period = "3 Min"), low(period = "3 Min")), length);
threeMinutesAdx = DMI(length, averageType).ADX;
threeMinutesPlus = 100 * MovingAverage(averageType, threeMinutesPlusDM, length) / threeMinutesATR;
threeMinutesMinus = 100 * MovingAverage(averageType, threeMinutesMinusDM, length) / threeMinutesATR;
threeMinutesBullishSignal = threeMinutesPlus crosses above threeMinutesMinus;
threeMinutesBearishSignal = threeMinutesPlus crosses below threeMinutesMinus;
threeMinutesNarrowRange = if threeMinutesMinus > threeMinutesPlus then threeMinutesMinus - threeMinutesPlus else if threeMinutesPlus > threeMinutesMinus then threeMinutesPlus - threeMinutesMinus else 0;
threeMinutesNarrowRangeTest = threeMinutesNarrowRange >= 10;
threeMinutesBullishZone = threeMinutesPlus > threeMinutesMinus and threeMinutesNarrowRangeTest;
threeMinutesBearishZone = threeMinutesPlus < threeMinutesMinus and threeMinutesNarrowRangeTest;
threeMinutesNeutralZone = !threeMinutesBullishZone and !threeMinutesBearishZone;
} else {
threeMinutesPlus = 0;
threeMinutesMinus = 0;
threeMinutesAdx = 0;
threeMinutesPlusDM = 0;
threeMinutesMinusDM = 0;
threeMinutesBullishSignal = 0;
threeMinutesBearishSignal = 0;
threeMinutesNarrowRange = 0;
threeMinutesNarrowRangeTest = 0;
threeMinutesBullishZone = 0;
threeMinutesBearishZone = 0;
threeMinutesNeutralZone = 0;
threeMinutesHiDiff = 0;
threeMinutesLoDiff = 0;
threeMinutesATR = 0;
}
AddLabel(threeMinutesBullishZone or threeMinutesBearishZone or threeMinutesNeutralZone, "3m", if threeMinutesBullishZone then Color.GREEN else if threeMinutesBearishZone then Color.RED else if threeMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def twoMinutesPlus;
def twoMinutesMinus;
def twoMinutesAdx;
def twoMinutesBullishSignal;
def twoMinutesBearishSignal;
def twoMinutesNarrowRange;
def twoMinutesNarrowRangeTest;
def twoMinutesBullishZone;
def twoMinutesBearishZone;
def twoMinutesNeutralZone;
def twoMinutesHiDiff;
def twoMinutesLoDiff;
def twoMinutesPlusDM;
def twoMinutesMinusDM;
def twoMinutesATR;
if GetAggregationPeriod() <= AggregationPeriod.TWO_MIN {
twoMinutesHiDiff = high(period = "2 Min") - high(period = "2 Min")[1];
twoMinutesLoDiff = low(period = "2 Min")[1] - low(period = "2 Min");
twoMinutesPlusDM = if twoMinutesHiDiff > twoMinutesLoDiff and twoMinutesHiDiff > 0 then twoMinutesHiDiff else 0;
twoMinutesMinusDM = if twoMinutesLoDiff > twoMinutesHiDiff and twoMinutesLoDiff > 0 then twoMinutesLoDiff else 0;
twoMinutesATR = MovingAverage(averageType, TrueRange(high(period = "2 Min"), close(period = "2 Min"), low(period = "2 Min")), length);
twoMinutesAdx = DMI(length, averageType).ADX;
twoMinutesPlus = 100 * MovingAverage(averageType, twoMinutesPlusDM, length) / twoMinutesATR;
twoMinutesMinus = 100 * MovingAverage(averageType, twoMinutesMinusDM, length) / twoMinutesATR;
twoMinutesBullishSignal = twoMinutesPlus crosses above twoMinutesMinus;
twoMinutesBearishSignal = twoMinutesPlus crosses below twoMinutesMinus;
twoMinutesNarrowRange = if twoMinutesMinus > twoMinutesPlus then twoMinutesMinus - twoMinutesPlus else if twoMinutesPlus > twoMinutesMinus then twoMinutesPlus - twoMinutesMinus else 0;
twoMinutesNarrowRangeTest = twoMinutesNarrowRange >= 10;
twoMinutesBullishZone = twoMinutesPlus > twoMinutesMinus and twoMinutesNarrowRangeTest;
twoMinutesBearishZone = twoMinutesPlus < twoMinutesMinus and twoMinutesNarrowRangeTest;
twoMinutesNeutralZone = !twoMinutesBullishZone and !twoMinutesBearishZone;
} else {
twoMinutesPlus = 0;
twoMinutesMinus = 0;
twoMinutesAdx = 0;
twoMinutesPlusDM = 0;
twoMinutesMinusDM = 0;
twoMinutesBullishSignal = 0;
twoMinutesBearishSignal = 0;
twoMinutesNarrowRange = 0;
twoMinutesNarrowRangeTest = 0;
twoMinutesBullishZone = 0;
twoMinutesBearishZone = 0;
twoMinutesNeutralZone = 0;
twoMinutesHiDiff = 0;
twoMinutesLoDiff = 0;
twoMinutesATR = 0;
}
AddLabel(twoMinutesBullishZone or twoMinutesBearishZone or twoMinutesNeutralZone, "2m", if twoMinutesBullishZone then Color.GREEN else if twoMinutesBearishZone then Color.RED else if twoMinutesNeutralZone then Color.YELLOW else Color.GRAY);
def minutesPlus;
def minutesMinus;
def minutesAdx;
def minutesBullishSignal;
def minutesBearishSignal;
def minutesNarrowRange;
def minutesNarrowRangeTest;
def minutesBullishZone;
def minutesBearishZone;
def minutesNeutralZone;
def minutesHiDiff;
def minutesLoDiff;
def minutesPlusDM;
def minutesMinusDM;
def minutesATR;
if GetAggregationPeriod() <= AggregationPeriod.MIN {
minutesHiDiff = high(period = "1 Min") - high(period = "1 Min")[1];
minutesLoDiff = low(period = "1 Min")[1] - low(period = "1 Min");
minutesPlusDM = if minutesHiDiff > minutesLoDiff and minutesHiDiff > 0 then minutesHiDiff else 0;
minutesMinusDM = if minutesLoDiff > minutesHiDiff and minutesLoDiff > 0 then minutesLoDiff else 0;
minutesATR = MovingAverage(averageType, TrueRange(high(period = "1 Min"), close(period = "1 Min"), low(period = "1 Min")), length);
minutesAdx = DMI(length, averageType).ADX;
minutesPlus = 100 * MovingAverage(averageType, minutesPlusDM, length) / minutesATR;
minutesMinus = 100 * MovingAverage(averageType, minutesMinusDM, length) / minutesATR;
minutesBullishSignal = minutesPlus crosses above minutesMinus;
minutesBearishSignal = minutesPlus crosses below minutesMinus;
minutesNarrowRange = if minutesMinus > minutesPlus then minutesMinus - minutesPlus else if minutesPlus > minutesMinus then minutesPlus - minutesMinus else 0;
minutesNarrowRangeTest = minutesNarrowRange >= 10;
minutesBullishZone = minutesPlus > minutesMinus and minutesNarrowRangeTest;
minutesBearishZone = minutesPlus < minutesMinus and minutesNarrowRangeTest;
minutesNeutralZone = !minutesBullishZone and !minutesBearishZone;
} else {
minutesPlus = 0;
minutesMinus = 0;
minutesAdx = 0;
minutesPlusDM = 0;
minutesMinusDM = 0;
minutesBullishSignal = 0;
minutesBearishSignal = 0;
minutesNarrowRange = 0;
minutesNarrowRangeTest = 0;
minutesBullishZone = 0;
minutesBearishZone = 0;
minutesNeutralZone = 0;
minutesHiDiff = 0;
minutesLoDiff = 0;
minutesATR = 0;
}
AddLabel(minutesBullishZone or minutesBearishZone or minutesNeutralZone, "1m", if minutesBullishZone then Color.GREEN else if minutesBearishZone then Color.RED else if minutesNeutralZone then Color.YELLOW else Color.GRAY);
Last edited by a moderator:
