Syntax Error Help

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:
Solution
Thank you MerryDay. I was looking for a simple answer/help. I have found the reason. You have to add following two lines at the top;

input length = 14;
input averageType = averageType.WILDERS;
@pgupta1646
The way to debug code:
Before creating a MTF indicator. You need to get the basic code to work. Take out all the aggregations.
Working sequentially:
Start with writing a moving average definition that works, verify its results on a chart. You can't define the True Range from within the moving average definition; create that separately. Then write a separate DMI definition that is tested and working.

If you have any issues with any ONE step come back with your script for that one definition. Explain what you are attempting to accomplish with that ONE definition. Provide a marked-up screenshot showing what it should be doing.

Unsure of how to upload screenshots to the forum, Here are directions.
 

Join useThinkScript to post your question to a community of 21,000+ developers and traders.

Thank you MerryDay. I was looking for a simple answer/help. I have found the reason. You have to add following two lines at the top;

input length = 14;
input averageType = averageType.WILDERS;
 
Solution

Similar threads

Not the exact question you're looking for?

Start a new thread and receive assistance from our community.

87k+ Posts
125 Online
Create Post

Similar threads

Similar threads

The Market Trading Game Changer

Join 2,500+ subscribers inside the useThinkScript VIP Membership Club
  • Exclusive indicators
  • Proven strategies & setups
  • Private Discord community
  • ‘Buy The Dip’ signal alerts
  • Exclusive members-only content
  • Add-ons and resources
  • 1 full year of unlimited support

Frequently Asked Questions

What is useThinkScript?

useThinkScript is the #1 community of stock market investors using indicators and other tools to power their trading strategies. Traders of all skill levels use our forums to learn about scripting and indicators, help each other, and discover new ways to gain an edge in the markets.

How do I get started?

We get it. Our forum can be intimidating, if not overwhelming. With thousands of topics, tens of thousands of posts, our community has created an incredibly deep knowledge base for stock traders. No one can ever exhaust every resource provided on our site.

If you are new, or just looking for guidance, here are some helpful links to get you started.

What are the benefits of VIP Membership?
VIP members get exclusive access to these proven and tested premium indicators: Buy the Dip, Advanced Market Moves 2.0, Take Profit, and Volatility Trading Range. In addition, VIP members get access to over 50 VIP-only custom indicators, add-ons, and strategies, private VIP-only forums, private Discord channel to discuss trades and strategies in real-time, customer support, trade alerts, and much more. Learn all about VIP membership here.
How can I access the premium indicators?
To access the premium indicators, which are plug and play ready, sign up for VIP membership here.
Back
Top