Quantity of Indicator Activations For ThinkOrSwim

[Trigun1127]

So I have 2 questions. Is there a bit of code that can be added to any indicator that will just output how many times the indicator has activated? Doesn't apply to line Plots and such just signals or bars that paint etc..? Perhaps a chart bubble that can say how many activations over whatever timeframe and Day aggregation?
Second question is can an indicator create something from the drawing tool box that can actually be "activated" and manipulated as any other normal drawing tool?

 

[halcyonguy]

So I have 2 questions. Is there a bit of code that can be added to any indicator that will just output how many times the indicator has activated? Doesn't apply to line Plots and such just signals or bars that paint etc..? Perhaps a chart bubble that can say how many activations over whatever timeframe and Day aggregation?
Second question is can an indicator create something from the drawing tool box that can actually be "activated" and manipulated as any other normal drawing tool?

1.
copy this to the end of a study
find this formula
def signal = t;
and replace t with your desired signal

# count_signals_00

def na = Double.NaN;
def bn = BarNumber();
#-----------------------
# test data
def x = Random() * 100;
input percent_of_test_signals = 20;
def t = (x <= percent_of_test_signals);
#-----------------------
# replace t,
# set desired signal variable equal to signal 
def signal = t;


#-----------------------
# signals on chart
def sig_cnt_chart = if bn == 1 and signal then 1
else if bn == 1 then 0
else if signal then sig_cnt_chart[1] + 1
else sig_cnt_chart[1];

addlabel(1, "quantity of Signal = True on chart " + sig_cnt_chart, color.yellow);

input show_signals_on_chart = yes;
def vert = 0.006;
plot z1 = if show_signals_on_chart and signal then high*(1+vert) else na;
z1.SetPaintingStrategy(PaintingStrategy.POINTS);
z1.SetDefaultColor(Color.cyan);
z1.setlineweight(2);
z1.hidebubble();

input show_signal_count_bubbles_on_chart = yes;
addchartbubble(show_signal_count_bubbles_on_chart and t, low*(1-vert),
 sig_cnt_chart
, color.yellow, no);
#

2. no

 

[Trigun1127]

Fantastic indicator! As an example Im confused what would be the signal for the close of either gap1up or gap1dn? I can use gap1up and gap1dn to determine their activations but Id like a seperate number that shows me how many of those closed

######################################################################################
#Definition of Signal. ###############################################################
######################################################################################
input Number_Of_Days = 2;
def agg = AggregationPeriod.DAY;
def LastDay = IsNaN(close(period = agg)[-Number_Of_Days]);

def Gap1Up = open [0] > close[1] and close > open and close[1] > open[1];
def Gap1Dn = open [0] < close[1] and close < open and close[1] < open[1];

def TailGapUp = 0;#low > high[2];
def TailGapDn = 0;#high < low[2];

def Gap3Up = 0;#open > close[2];
def Gap3Dn = 0;#open < close[2];
######################################################################################
#Defintions of Support Levels.########################################################
######################################################################################
plot SupportLevel = if Gap1Up and LastDay then open else if TailGapUp and LastDay then open else if Gap3Up and LastDay then open else Double.NaN;
SupportLevel.SetPaintingStrategy(PaintingStrategy.VALUES_BELOW);
SupportLevel.Hide();

def SLine0;
def SLine1;
def SLine2;
def SLine3;
def SLine4;
def SLine5;
def SLine6;
def SLine7;
def SLine8;
def SLine9;
def SLine10;
def SLine11;
def SLine12;
def SLine13;
def SLine14;
def SLine15;
def SLine16;
def SLine17;
def SLine18;
def SLine19;
def SLine20;

def SLineCount;
if BarNumber()==1 { SLineCount = 0;
#}else if SecondsTillTime(0000) == 0 { SLineCount = 0;
}else if (IsNaN(SupportLevel) and SLine0[1]<>0 and close<=SLine0[1]) { SLineCount=20;
}else if (IsNaN(SupportLevel) and SLine1[1]<>0 and close<=SLine1[1]) { SLineCount=0;
}else if (IsNaN(SupportLevel) and SLine2[1]<>0 and close<=SLine2[1]) { SLineCount=1;
}else if (IsNaN(SupportLevel) and SLine3[1]<>0 and close<=SLine3[1]) { SLineCount=2;
}else if (IsNaN(SupportLevel) and SLine4[1]<>0 and close<=SLine4[1]) { SLineCount=3;
}else if (IsNaN(SupportLevel) and SLine5[1]<>0 and close<=SLine5[1]) { SLineCount=4;
}else if (IsNaN(SupportLevel) and SLine6[1]<>0 and close<=SLine6[1]) { SLineCount=5;
}else if (IsNaN(SupportLevel) and SLine7[1]<>0 and close<=SLine7[1]) { SLineCount=6;
}else if (IsNaN(SupportLevel) and SLine8[1]<>0 and close<=SLine8[1]) { SLineCount=7;
}else if (IsNaN(SupportLevel) and SLine9[1]<>0 and close<=SLine9[1]) { SLineCount=8;
}else if (IsNaN(SupportLevel) and SLine10[1]<>0 and close<=SLine10[1]) { SLineCount=9;
}else if (IsNaN(SupportLevel) and SLine11[1]<>0 and close<=SLine11[1]) { SLineCount=10;
}else if (IsNaN(SupportLevel) and SLine12[1]<>0 and close<=SLine12[1]) { SLineCount=11;
}else if (IsNaN(SupportLevel) and SLine13[1]<>0 and close<=SLine13[1]) { SLineCount=12;
}else if (IsNaN(SupportLevel) and SLine14[1]<>0 and close<=SLine14[1]) { SLineCount=13;
}else if (IsNaN(SupportLevel) and SLine15[1]<>0 and close<=SLine15[1]) { SLineCount=14;
}else if (IsNaN(SupportLevel) and SLine16[1]<>0 and close<=SLine16[1]) { SLineCount=15;
}else if (IsNaN(SupportLevel) and SLine17[1]<>0 and close<=SLine17[1]) { SLineCount=16;
}else if (IsNaN(SupportLevel) and SLine18[1]<>0 and close<=SLine18[1]) { SLineCount=17;
}else if (IsNaN(SupportLevel) and SLine19[1]<>0 and close<=SLine19[1]) { SLineCount=18;
}else if (IsNaN(SupportLevel) and SLine20[1]<>0 and close<=SLine20[1]) { SLineCount=19;

}else if (!IsNaN(SupportLevel) and SLine0[1]<>0 and close<=SLine0[1]) { SLineCount=0;
}else if (!IsNaN(SupportLevel) and SLine1[1]<>0 and close<=SLine1[1]) { SLineCount=1;
}else if (!IsNaN(SupportLevel) and SLine2[1]<>0 and close<=SLine2[1]) { SLineCount=2;
}else if (!IsNaN(SupportLevel) and SLine3[1]<>0 and close<=SLine3[1]) { SLineCount=3;
}else if (!IsNaN(SupportLevel) and SLine4[1]<>0 and close<=SLine4[1]) { SLineCount=4;
}else if (!IsNaN(SupportLevel) and SLine5[1]<>0 and close<=SLine5[1]) { SLineCount=5;
}else if (!IsNaN(SupportLevel) and SLine6[1]<>0 and close<=SLine6[1]) { SLineCount=6;
}else if (!IsNaN(SupportLevel) and SLine7[1]<>0 and close<=SLine7[1]) { SLineCount=7;
}else if (!IsNaN(SupportLevel) and SLine8[1]<>0 and close<=SLine8[1]) { SLineCount=8;
}else if (!IsNaN(SupportLevel) and SLine9[1]<>0 and close<=SLine9[1]) { SLineCount=9;
}else if (!IsNaN(SupportLevel) and SLine10[1]<>0 and close<=SLine10[1]) { SLineCount=10;
}else if (!IsNaN(SupportLevel) and SLine11[1]<>0 and close<=SLine11[1]) { SLineCount=11;
}else if (!IsNaN(SupportLevel) and SLine12[1]<>0 and close<=SLine12[1]) { SLineCount=12;
}else if (!IsNaN(SupportLevel) and SLine13[1]<>0 and close<=SLine13[1]) { SLineCount=13;
}else if (!IsNaN(SupportLevel) and SLine14[1]<>0 and close<=SLine14[1]) { SLineCount=14;
}else if (!IsNaN(SupportLevel) and SLine15[1]<>0 and close<=SLine15[1]) { SLineCount=15;
}else if (!IsNaN(SupportLevel) and SLine16[1]<>0 and close<=SLine16[1]) { SLineCount=16;
}else if (!IsNaN(SupportLevel) and SLine17[1]<>0 and close<=SLine17[1]) { SLineCount=17;
}else if (!IsNaN(SupportLevel) and SLine18[1]<>0 and close<=SLine18[1]) { SLineCount=18;
}else if (!IsNaN(SupportLevel) and SLine19[1]<>0 and close<=SLine19[1]) { SLineCount=19;
}else if (!IsNaN(SupportLevel) and SLine20[1]<>0 and close<=SLine20[1]) { SLineCount=20;
}else if (!IsNaN(SupportLevel)) and SLineCount[1]!=20 { SLineCount = SLineCount[1] + 1;
}else if (!IsNaN(SupportLevel)) and SLineCount[1]==20 { SLineCount = 0;
} else {
    SLineCount = SLineCount[1];
}

#green candles
######################################################################################
#Plots of Support Levels. ############################################################
######################################################################################
SLine0 = if !IsNaN(SupportLevel) and SLineCount == 0 then SupportLevel else if IsNaN(close) then SLine0[1] else if !IsNaN(SLine0[1]) and close <= SLine0[1] then 0 else SLine0[1];
plot SLineP0 = if SLine0 > 0 then SLine0 else Double.NaN;
SLineP0.SetStyle(Curve.POINTS);
SLineP0.SetDefaultColor(Color.LIGHT_GREEN);
SLineP0.SetLineWeight(1);
SLineP0.HideBubble();
#----------------------------------------------------------------------------------
SLine1 = if !IsNaN(SupportLevel) and SLineCount == 1 then SupportLevel else if IsNaN(close) then SLine1[1] else if !IsNaN(SLine1[1]) and close <= SLine1[1] then 0 else SLine1[1];
plot SLineP1 = if SLine1 > 0 then SLine1 else Double.NaN;
SLineP1.SetStyle(Curve.POINTS);
SLineP1.SetDefaultColor(Color.LIGHT_GREEN);
SLineP1.SetLineWeight(1);
SLineP1.HideBubble();
#----------------------------------------------------------------------------------
SLine2 = if !IsNaN(SupportLevel) and SLineCount == 2 then SupportLevel else if IsNaN(close) then SLine2[1] else if !IsNaN(SLine2[1]) and close <= SLine2[1] then 0 else SLine2[1];
plot SLineP2 = if SLine2 > 0 then SLine2 else Double.NaN;
SLineP2.SetStyle(Curve.POINTS);
SLineP2.SetDefaultColor(Color.LIGHT_GREEN);
SLineP2.SetLineWeight(1);
SLineP2.HideBubble();
#----------------------------------------------------------------------------------
SLine3 = if !IsNaN(SupportLevel) and SLineCount == 3 then SupportLevel else if IsNaN(close) then SLine3[1] else if !IsNaN(SLine3[1]) and close <= SLine3[1] then 0 else SLine3[1];
plot SLineP3 = if SLine3 > 0 then SLine3 else Double.NaN;
SLineP3.SetStyle(Curve.POINTS);
SLineP3.SetDefaultColor(Color.LIGHT_GREEN);
SLineP3.SetLineWeight(1);
SLineP3.HideBubble();
#----------------------------------------------------------------------------------
SLine4 = if !IsNaN(SupportLevel) and SLineCount == 4 then SupportLevel else if IsNaN(close) then SLine4[1] else if !IsNaN(SLine4[1]) and close <= SLine4[1] then 0 else SLine4[1];
plot SLineP4 = if SLine4 > 0 then SLine4 else Double.NaN;
SLineP4.SetStyle(Curve.POINTS);
SLineP4.SetDefaultColor(Color.LIGHT_GREEN);
SLineP4.SetLineWeight(1);
SLineP4.HideBubble();
#----------------------------------------------------------------------------------
SLine5 = if !IsNaN(SupportLevel) and SLineCount == 5 then SupportLevel else if IsNaN(close) then SLine5[1] else if !IsNaN(SLine5[1]) and close <= SLine5[1] then 0 else SLine5[1];
plot SLineP5 = if SLine5 > 0 then SLine5 else Double.NaN;
SLineP5.SetStyle(Curve.POINTS);
SLineP5.SetDefaultColor(Color.LIGHT_GREEN);
SLineP5.SetLineWeight(1);
SLineP5.HideBubble();
#----------------------------------------------------------------------------------
SLine6 = if !IsNaN(SupportLevel) and SLineCount == 6 then SupportLevel else if IsNaN(close) then SLine6[1] else if !IsNaN(SLine6[1]) and low <= SLine6[1] then 0 else SLine6[1];
plot SLineP6 = if SLine6 > 0 then SLine6 else Double.NaN;
SLineP6.SetStyle(Curve.POINTS);
SLineP6.SetDefaultColor(Color.LIGHT_GREEN);
SLineP6.SetLineWeight(1);
SLineP6.HideBubble();
#----------------------------------------------------------------------------------
SLine7 = if !IsNaN(SupportLevel) and SLineCount == 7 then SupportLevel else if IsNaN(close) then SLine7[1] else if !IsNaN(SLine7[1]) and close <= SLine7[1] then 0 else SLine7[1];
plot SLineP7 = if SLine7 > 0 then SLine7 else Double.NaN;
SLineP7.SetStyle(Curve.POINTS);
SLineP7.SetDefaultColor(Color.LIGHT_GREEN);
SLineP7.SetLineWeight(1);
SLineP7.HideBubble();
#----------------------------------------------------------------------------------
SLine8 = if !IsNaN(SupportLevel) and SLineCount == 8 then SupportLevel else if IsNaN(close) then SLine8[1] else if !IsNaN(SLine8[1]) and close <= SLine8[1] then 0 else SLine8[1];
plot SLineP8 = if SLine8 > 0 then SLine8 else Double.NaN;
SLineP8.SetStyle(Curve.POINTS);
SLineP8.SetDefaultColor(Color.LIGHT_GREEN);
SLineP8.SetLineWeight(1);
SLineP8.HideBubble();
#----------------------------------------------------------------------------------
SLine9 = if !IsNaN(SupportLevel) and SLineCount == 9 then SupportLevel else if IsNaN(close) then SLine9[1] else if !IsNaN(SLine9[1]) and close <= SLine9[1] then 0 else SLine9[1];
plot SLineP9 = if SLine9 > 0 then SLine9 else Double.NaN;
SLineP9.SetStyle(Curve.POINTS);
SLineP9.SetDefaultColor(Color.LIGHT_GREEN);
SLineP9.SetLineWeight(1);
SLineP9.HideBubble();
#----------------------------------------------------------------------------------
SLine10 = if !IsNaN(SupportLevel) and SLineCount == 10 then SupportLevel else if IsNaN(close) then SLine10[1] else if !IsNaN(SLine10[1]) and close <= SLine10[1] then 0 else SLine10[1];
plot SLineP10 = if SLine10 > 0 then SLine10 else Double.NaN;
SLineP10.SetStyle(Curve.POINTS);
SLineP10.SetDefaultColor(Color.LIGHT_GREEN);
SLineP10.SetLineWeight(1);
SLineP10.HideBubble();
#----------------------------------------------------------------------------------
SLine11 = if !IsNaN(SupportLevel) and SLineCount == 11 then SupportLevel else if IsNaN(close) then SLine11[1] else if !IsNaN(SLine11[1]) and close <= SLine11[1] then 0 else SLine11[1];
plot SLineP11 = if SLine11 > 0 then SLine11 else Double.NaN;
SLineP11.SetStyle(Curve.POINTS);
SLineP11.SetDefaultColor(Color.LIGHT_GREEN);
SLineP11.SetLineWeight(1);
SLineP11.HideBubble();
#----------------------------------------------------------------------------------
SLine12 = if !IsNaN(SupportLevel) and SLineCount == 12 then SupportLevel else if IsNaN(close) then SLine12[1] else if !IsNaN(SLine12[1]) and close <= SLine12[1] then 0 else SLine12[1];
plot SLineP12 = if SLine12 > 0 then SLine12 else Double.NaN;
SLineP12.SetStyle(Curve.POINTS);
SLineP12.SetDefaultColor(Color.LIGHT_GREEN);
SLineP12.SetLineWeight(1);
SLineP12.HideBubble();
#----------------------------------------------------------------------------------
SLine13 = if !IsNaN(SupportLevel) and SLineCount == 13 then SupportLevel else if IsNaN(close) then SLine13[1] else if !IsNaN(SLine13[1]) and close <= SLine13[1] then 0 else SLine13[1];
plot SLineP13 = if SLine13 > 0 then SLine13 else Double.NaN;
SLineP13.SetStyle(Curve.POINTS);
SLineP13.SetDefaultColor(Color.LIGHT_GREEN);
SLineP13.SetLineWeight(1);
SLineP13.HideBubble();
#----------------------------------------------------------------------------------
SLine14 = if !IsNaN(SupportLevel) and SLineCount == 14 then SupportLevel else if IsNaN(close) then SLine14[1] else if !IsNaN(SLine14[1]) and close <= SLine14[1] then 0 else SLine14[1];
plot SLineP14 = if SLine14 > 0 then SLine14 else Double.NaN;
SLineP14.SetStyle(Curve.POINTS);
SLineP14.SetDefaultColor(Color.LIGHT_GREEN);
SLineP14.SetLineWeight(1);
SLineP14.HideBubble();
#----------------------------------------------------------------------------------
SLine15 = if !IsNaN(SupportLevel) and SLineCount == 15 then SupportLevel else if IsNaN(close) then SLine15[1] else if !IsNaN(SLine15[1]) and close <= SLine15[1] then 0 else SLine15[1];
plot SLineP15 = if SLine15 > 0 then SLine15 else Double.NaN;
SLineP15.SetStyle(Curve.POINTS);
SLineP15.SetDefaultColor(Color.LIGHT_GREEN);
SLineP15.SetLineWeight(1);
SLineP15.HideBubble();
#----------------------------------------------------------------------------------
SLine16 = if !IsNaN(SupportLevel) and SLineCount == 16 then SupportLevel else if IsNaN(close) then SLine16[1] else if !IsNaN(SLine16[1]) and close <= SLine16[1] then 0 else SLine16[1];
plot SLineP16 = if SLine16 > 0 then SLine16 else Double.NaN;
SLineP16.SetStyle(Curve.POINTS);
SLineP16.SetDefaultColor(Color.LIGHT_GREEN);
SLineP16.SetLineWeight(1);
SLineP16.HideBubble();
#----------------------------------------------------------------------------------
SLine17 = if !IsNaN(SupportLevel) and SLineCount == 17 then SupportLevel else if IsNaN(close) then SLine17[1] else if !IsNaN(SLine17[1]) and close <= SLine17[1] then 0 else SLine17[1];
plot SLineP17 = if SLine17 > 0 then SLine17 else Double.NaN;
SLineP17.SetStyle(Curve.POINTS);
SLineP17.SetDefaultColor(Color.LIGHT_GREEN);
SLineP17.SetLineWeight(1);
SLineP17.HideBubble();
#----------------------------------------------------------------------------------
SLine18 = if !IsNaN(SupportLevel) and SLineCount == 18 then SupportLevel else if IsNaN(close) then SLine18[1] else if !IsNaN(SLine18[1]) and close < SLine18[1] then 0 else SLine18[1];
plot SLineP18 = if SLine18 > 0 then SLine18 else Double.NaN;
SLineP18.SetStyle(Curve.POINTS);
SLineP18.SetDefaultColor(Color.LIGHT_GREEN);
SLineP18.SetLineWeight(1);
SLineP18.HideBubble();
#----------------------------------------------------------------------------------
SLine19 = if !IsNaN(SupportLevel) and SLineCount == 19 then SupportLevel else if IsNaN(close) then SLine19[1] else if !IsNaN(SLine19[1]) and close <= SLine19[1] then 0 else SLine19[1];
plot SLineP19 = if SLine19 > 0 then SLine19 else Double.NaN;
SLineP19.SetStyle(Curve.POINTS);
SLineP19.SetDefaultColor(Color.LIGHT_GREEN);
SLineP19.SetLineWeight(1);
SLineP19.HideBubble();
#----------------------------------------------------------------------------------
SLine20 = if !IsNaN(SupportLevel) and SLineCount == 20 then SupportLevel else if IsNaN(close) then SLine20[1] else if !IsNaN(SLine20[1]) and close <= SLine20[1] then 0 else SLine20[1];
plot SLineP20 = if SLine20 > 0 then SLine20 else Double.NaN;
SLineP20.SetStyle(Curve.POINTS);
SLineP20.SetDefaultColor(Color.CYAN);
SLineP20.SetLineWeight(1);
SLineP20.HideBubble();
#----------------------------------------------------------------------------------
#####################################################################################
########################################################################################


#red candles
######################################################################################
#Definitons of Resistance Levels.#####################################################
######################################################################################
plot ResistanceLevel = if Gap1Dn and LastDay then open else if TailGapDn and LastDay then open else if Gap3Dn and LastDay then open else Double.NaN;
ResistanceLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);
ResistanceLevel.Hide();

def RLine0;
def RLine1;
def RLine2;
def RLine3;
def RLine4;
def RLine5;
def RLine6;
def RLine7;
def RLine8;
def RLine9;
def RLine10;
def RLine11;
def RLine12;
def RLine13;
def RLine14;
def RLine15;
def RLine16;
def RLine17;
def RLine18;
def RLine19;
def RLine20;

def RLineCount;
if BarNumber()==1 { RLineCount = 0;
#}else if SecondsTillTime(0000) == 0 { RLineCount = 0;
}else if (IsNaN(ResistanceLevel) and RLine0[1]<>0 and close>=RLine0[1]) { RLineCount=20;
}else if (IsNaN(ResistanceLevel) and RLine1[1]<>0 and close>=RLine1[1]) { RLineCount=0;
}else if (IsNaN(ResistanceLevel) and RLine2[1]<>0 and close>=RLine2[1]) { RLineCount=1;
}else if (IsNaN(ResistanceLevel) and RLine3[1]<>0 and close>=RLine3[1]) { RLineCount=2;
}else if (IsNaN(ResistanceLevel) and RLine4[1]<>0 and close>=RLine4[1]) { RLineCount=3;
}else if (IsNaN(ResistanceLevel) and RLine5[1]<>0 and close>=RLine5[1]) { RLineCount=4;
}else if (IsNaN(ResistanceLevel) and RLine6[1]<>0 and close>=RLine6[1]) { RLineCount=5;
}else if (IsNaN(ResistanceLevel) and RLine7[1]<>0 and close>=RLine7[1]) { RLineCount=6;
}else if (IsNaN(ResistanceLevel) and RLine8[1]<>0 and close>=RLine8[1]) { RLineCount=7;
}else if (IsNaN(ResistanceLevel) and RLine9[1]<>0 and close>=RLine9[1]) { RLineCount=8;
}else if (IsNaN(ResistanceLevel) and RLine10[1]<>0 and close>=RLine10[1]) { RLineCount=9;
}else if (IsNaN(ResistanceLevel) and RLine11[1]<>0 and close>=RLine11[1]) { RLineCount=10;
}else if (IsNaN(ResistanceLevel) and RLine12[1]<>0 and close>=RLine12[1]) { RLineCount=11;
}else if (IsNaN(ResistanceLevel) and RLine13[1]<>0 and close>=RLine13[1]) { RLineCount=12;
}else if (IsNaN(ResistanceLevel) and RLine14[1]<>0 and close>=RLine14[1]) { RLineCount=13;
}else if (IsNaN(ResistanceLevel) and RLine15[1]<>0 and close>=RLine15[1]) { RLineCount=14;
}else if (IsNaN(ResistanceLevel) and RLine16[1]<>0 and close>=RLine16[1]) { RLineCount=15;
}else if (IsNaN(ResistanceLevel) and RLine17[1]<>0 and close>=RLine17[1]) { RLineCount=16;
}else if (IsNaN(ResistanceLevel) and RLine18[1]<>0 and close>=RLine18[1]) { RLineCount=17;
}else if (IsNaN(ResistanceLevel) and RLine19[1]<>0 and close>=RLine19[1]) { RLineCount=18;
}else if (IsNaN(ResistanceLevel) and RLine20[1]<>0 and close>=RLine20[1]) { RLineCount=19;

}else if (!IsNaN(ResistanceLevel) and RLine0[1]<>0 and close>=RLine0[1]) { RLineCount=0;
}else if (!IsNaN(ResistanceLevel) and RLine1[1]<>0 and close>=RLine1[1]) { RLineCount=1;
}else if (!IsNaN(ResistanceLevel) and RLine2[1]<>0 and close>=RLine2[1]) { RLineCount=2;
}else if (!IsNaN(ResistanceLevel) and RLine3[1]<>0 and close>=RLine3[1]) { RLineCount=3;
}else if (!IsNaN(ResistanceLevel) and RLine4[1]<>0 and close>=RLine4[1]) { RLineCount=4;
}else if (!IsNaN(ResistanceLevel) and RLine5[1]<>0 and close>=RLine5[1]) { RLineCount=5;
}else if (!IsNaN(ResistanceLevel) and RLine6[1]<>0 and close>=RLine6[1]) { RLineCount=6;
}else if (!IsNaN(ResistanceLevel) and RLine7[1]<>0 and close>=RLine7[1]) { RLineCount=7;
}else if (!IsNaN(ResistanceLevel) and RLine8[1]<>0 and close>=RLine8[1]) { RLineCount=8;
}else if (!IsNaN(ResistanceLevel) and RLine9[1]<>0 and close>=RLine9[1]) { RLineCount=9;
}else if (!IsNaN(ResistanceLevel) and RLine10[1]<>0 and close>=RLine10[1]) { RLineCount=10;
}else if (!IsNaN(ResistanceLevel) and RLine11[1]<>0 and close>=RLine11[1]) { RLineCount=11;
}else if (!IsNaN(ResistanceLevel) and RLine12[1]<>0 and close>=RLine12[1]) { RLineCount=12;
}else if (!IsNaN(ResistanceLevel) and RLine13[1]<>0 and close>=RLine13[1]) { RLineCount=13;
}else if (!IsNaN(ResistanceLevel) and RLine14[1]<>0 and close>=RLine14[1]) { RLineCount=14;
}else if (!IsNaN(ResistanceLevel) and RLine15[1]<>0 and close>=RLine15[1]) { RLineCount=15;
}else if (!IsNaN(ResistanceLevel) and RLine16[1]<>0 and close>=RLine16[1]) { RLineCount=16;
}else if (!IsNaN(ResistanceLevel) and RLine17[1]<>0 and close>=RLine17[1]) { RLineCount=17;
}else if (!IsNaN(ResistanceLevel) and RLine18[1]<>0 and close>=RLine18[1]) { RLineCount=18;
}else if (!IsNaN(ResistanceLevel) and RLine19[1]<>0 and close>=RLine19[1]) { RLineCount=19;
}else if (!IsNaN(ResistanceLevel) and RLine20[1]<>0 and close>=RLine20[1]) { RLineCount=20;
}else if (!IsNaN(ResistanceLevel)) and RLineCount[1]!=20 { RLineCount = RLineCount[1] + 1;
}else if (!IsNaN(ResistanceLevel)) and RLineCount[1]==20 { RLineCount = 0;
} else {
    RLineCount = RLineCount[1];
}

######################################################################################
#Plots of Resistance Levels.##########################################################
######################################################################################
RLine0 = if !IsNaN(ResistanceLevel) and RLineCount == 0 then ResistanceLevel else if IsNaN(close) then RLine0[1] else if !IsNaN(RLine0[1]) and close >= RLine0[1] then 0 else RLine0[1];
plot RLineP0 = if RLine0 > 0 then RLine0 else Double.NaN;
RLineP0.SetStyle(Curve.POINTS);
RLineP0.SetDefaultColor(Color.LIGHT_RED);
RLineP0.SetLineWeight(1);
RLineP0.HideBubble();
#----------------------------------------------------------------------------------
RLine1 = if !IsNaN(ResistanceLevel) and RLineCount == 1 then ResistanceLevel else if IsNaN(close) then RLine1[1] else if !IsNaN(RLine1[1]) and close >= RLine1[1] then 0 else RLine1[1];
plot RLineP1 = if RLine1 > 0 then RLine1 else Double.NaN;
RLineP1.SetStyle(Curve.POINTS);
RLineP1.SetDefaultColor(Color.LIGHT_RED);
RLineP1.SetLineWeight(1);
RLineP1.HideBubble();
#----------------------------------------------------------------------------------
RLine2 = if !IsNaN(ResistanceLevel) and RLineCount == 2 then ResistanceLevel else if IsNaN(close) then RLine2[1] else if !IsNaN(RLine2[1]) and close >= RLine2[1] then 0 else RLine2[1];
plot RLineP2 = if RLine2 > 0 then RLine2 else Double.NaN;
RLineP2.SetStyle(Curve.POINTS);
RLineP2.SetDefaultColor(Color.LIGHT_RED);
RLineP2.SetLineWeight(1);
RLineP2.HideBubble();
#----------------------------------------------------------------------------------
RLine3 = if !IsNaN(ResistanceLevel) and RLineCount == 3 then ResistanceLevel else if IsNaN(close) then RLine3[1] else if !IsNaN(RLine3[1]) and close >= RLine3[1] then 0 else RLine3[1];
plot RLineP3 = if RLine3 > 0 then RLine3 else Double.NaN;
RLineP3.SetStyle(Curve.POINTS);
RLineP3.SetDefaultColor(Color.LIGHT_RED);
RLineP3.SetLineWeight(1);
RLineP3.HideBubble();
#----------------------------------------------------------------------------------
RLine4 = if !IsNaN(ResistanceLevel) and RLineCount == 4 then ResistanceLevel else if IsNaN(close) then RLine4[1] else if !IsNaN(RLine4[1]) and close >= RLine4[1] then 0 else RLine4[1];
plot RLineP4 = if RLine4 > 0 then RLine4 else Double.NaN;
RLineP4.SetStyle(Curve.POINTS);
RLineP4.SetDefaultColor(Color.LIGHT_RED);
RLineP4.SetLineWeight(1);
RLineP4.HideBubble();
#----------------------------------------------------------------------------------
RLine5 = if !IsNaN(ResistanceLevel) and RLineCount == 5 then ResistanceLevel else if IsNaN(close) then RLine5[1] else if !IsNaN(RLine5[1]) and close >= RLine5[1] then 0 else RLine5[1];
plot RLineP5 = if RLine5 > 0 then RLine5 else Double.NaN;
RLineP5.SetStyle(Curve.POINTS);
RLineP5.SetDefaultColor(Color.LIGHT_RED);
RLineP5.SetLineWeight(1);
RLineP5.HideBubble();
#----------------------------------------------------------------------------------
RLine6 = if !IsNaN(ResistanceLevel) and RLineCount == 6 then ResistanceLevel else if IsNaN(close) then RLine6[1] else if !IsNaN(RLine6[1]) and close >= RLine6[1] then 0 else RLine6[1];
plot RLineP6 = if RLine6 > 0 then RLine6 else Double.NaN;
RLineP6.SetStyle(Curve.POINTS);
RLineP6.SetDefaultColor(Color.LIGHT_RED);
RLineP6.SetLineWeight(1);
RLineP6.HideBubble();
#----------------------------------------------------------------------------------
RLine7 = if !IsNaN(ResistanceLevel) and RLineCount == 7 then ResistanceLevel else if IsNaN(close) then RLine7[1] else if !IsNaN(RLine7[1]) and close >= RLine7[1] then 0 else RLine7[1];
plot RLineP7 = if RLine7 > 0 then RLine7 else Double.NaN;
RLineP7.SetStyle(Curve.POINTS);
RLineP7.SetDefaultColor(Color.LIGHT_RED);
RLineP7.SetLineWeight(1);
RLineP7.HideBubble();
#----------------------------------------------------------------------------------
RLine8 = if !IsNaN(ResistanceLevel) and RLineCount == 8 then ResistanceLevel else if IsNaN(close) then RLine8[1] else if !IsNaN(RLine8[1]) and close >= RLine8[1] then 0 else RLine8[1];
plot RLineP8 = if RLine8 > 0 then RLine8 else Double.NaN;
RLineP8.SetStyle(Curve.POINTS);
RLineP8.SetDefaultColor(Color.LIGHT_RED);
RLineP8.SetLineWeight(1);
RLineP8.HideBubble();
#----------------------------------------------------------------------------------
RLine9 = if !IsNaN(ResistanceLevel) and RLineCount == 9 then ResistanceLevel else if IsNaN(close) then RLine9[1] else if !IsNaN(RLine9[1]) and close >= RLine9[1] then 0 else RLine9[1];
plot RLineP9 = if RLine9 > 0 then RLine9 else Double.NaN;
RLineP9.SetStyle(Curve.POINTS);
RLineP9.SetDefaultColor(Color.LIGHT_RED);
RLineP9.SetLineWeight(1);
RLineP9.HideBubble();
#----------------------------------------------------------------------------------
RLine10 = if !IsNaN(ResistanceLevel) and RLineCount == 10 then ResistanceLevel else if IsNaN(close) then RLine10[1] else if !IsNaN(RLine10[1]) and close >= RLine10[1] then 0 else RLine10[1];
plot RLineP10 = if RLine10 > 0 then RLine10 else Double.NaN;
RLineP10.SetStyle(Curve.POINTS);
RLineP10.SetDefaultColor(Color.LIGHT_RED);
RLineP10.SetLineWeight(1);
RLineP10.HideBubble();
#----------------------------------------------------------------------------------
RLine11 = if !IsNaN(ResistanceLevel) and RLineCount == 11 then ResistanceLevel else if IsNaN(close) then RLine11[1] else if !IsNaN(RLine11[1]) and close >= RLine11[1] then 0 else RLine11[1];
plot RLineP11 = if RLine11 > 0 then RLine11 else Double.NaN;
RLineP11.SetStyle(Curve.POINTS);
RLineP11.SetDefaultColor(Color.LIGHT_RED);
RLineP11.SetLineWeight(1);
RLineP11.HideBubble();
#----------------------------------------------------------------------------------
RLine12 = if !IsNaN(ResistanceLevel) and RLineCount == 12 then ResistanceLevel else if IsNaN(close) then RLine12[1] else if !IsNaN(RLine12[1]) and close >= RLine12[1] then 0 else RLine12[1];
plot RLineP12 = if RLine12 > 0 then RLine12 else Double.NaN;
RLineP12.SetStyle(Curve.POINTS);
RLineP12.SetDefaultColor(Color.LIGHT_RED);
RLineP12.SetLineWeight(1);
RLineP12.HideBubble();
#----------------------------------------------------------------------------------
RLine13 = if !IsNaN(ResistanceLevel) and RLineCount == 13 then ResistanceLevel else if IsNaN(close) then RLine13[1] else if !IsNaN(RLine13[1]) and close >= RLine13[1] then 0 else RLine13[1];
plot RLineP13 = if RLine13 > 0 then RLine13 else Double.NaN;
RLineP13.SetStyle(Curve.POINTS);
RLineP13.SetDefaultColor(Color.LIGHT_RED);
RLineP13.SetLineWeight(1);
RLineP13.HideBubble();
#----------------------------------------------------------------------------------
RLine14 = if !IsNaN(ResistanceLevel) and RLineCount == 14 then ResistanceLevel else if IsNaN(close) then RLine14[1] else if !IsNaN(RLine14[1]) and close >= RLine14[1] then 0 else RLine14[1];
plot RLineP14 = if RLine14 > 0 then RLine14 else Double.NaN;
RLineP14.SetStyle(Curve.POINTS);
RLineP14.SetDefaultColor(Color.LIGHT_RED);
RLineP14.SetLineWeight(1);
RLineP14.HideBubble();
#----------------------------------------------------------------------------------
RLine15 = if !IsNaN(ResistanceLevel) and RLineCount == 15 then ResistanceLevel else if IsNaN(close) then RLine15[1] else if !IsNaN(RLine15[1]) and close >= RLine15[1] then 0 else RLine15[1];
plot RLineP15 = if RLine15 > 0 then RLine15 else Double.NaN;
RLineP15.SetStyle(Curve.POINTS);
RLineP15.SetDefaultColor(Color.LIGHT_RED);
RLineP15.SetLineWeight(1);
RLineP15.HideBubble();
#----------------------------------------------------------------------------------
RLine16 = if !IsNaN(ResistanceLevel) and RLineCount == 16 then ResistanceLevel else if IsNaN(close) then RLine16[1] else if !IsNaN(RLine16[1]) and close >= RLine16[1] then 0 else RLine16[1];
plot RLineP16 = if RLine16 > 0 then RLine16 else Double.NaN;
RLineP16.SetStyle(Curve.POINTS);
RLineP16.SetDefaultColor(Color.LIGHT_RED);
RLineP16.SetLineWeight(1);
RLineP16.HideBubble();
#----------------------------------------------------------------------------------
RLine17 = if !IsNaN(ResistanceLevel) and RLineCount == 17 then ResistanceLevel else if IsNaN(close) then RLine17[1] else if !IsNaN(RLine17[1]) and close >= RLine17[1] then 0 else RLine17[1];
plot RLineP17 = if RLine17 > 0 then RLine17 else Double.NaN;
RLineP17.SetStyle(Curve.POINTS);
RLineP17.SetDefaultColor(Color.LIGHT_RED);
RLineP17.SetLineWeight(1);
RLineP17.HideBubble();
#----------------------------------------------------------------------------------
RLine18 = if !IsNaN(ResistanceLevel) and RLineCount == 18 then ResistanceLevel else if IsNaN(close) then RLine18[1] else if !IsNaN(RLine18[1]) and close >= RLine18[1] then 0 else RLine18[1];
plot RLineP18 = if RLine18 > 0 then RLine18 else Double.NaN;
RLineP18.SetStyle(Curve.POINTS);
RLineP18.SetDefaultColor(Color.LIGHT_RED);
RLineP18.SetLineWeight(1);
RLineP18.HideBubble();
#----------------------------------------------------------------------------------
RLine19 = if !IsNaN(ResistanceLevel) and RLineCount == 19 then ResistanceLevel else if IsNaN(close) then RLine19[1] else if !IsNaN(RLine19[1]) and close >= RLine19[1] then 0 else RLine19[1];
plot RLineP19 = if RLine19 > 0 then RLine19 else Double.NaN;
RLineP19.SetStyle(Curve.POINTS);
RLineP19.SetDefaultColor(Color.LIGHT_RED);
RLineP19.SetLineWeight(1);
RLineP19.HideBubble();
#----------------------------------------------------------------------------------
RLine20 = if !IsNaN(ResistanceLevel) and RLineCount == 20 then ResistanceLevel else if IsNaN(close) then RLine20[1] else if !IsNaN(RLine20[1]) and high >= RLine20[1] then 0 else RLine20[1];
plot RLineP20 = if RLine20 > 0 then RLine20 else Double.NaN;
RLineP20.SetStyle(Curve.POINTS);
RLineP20.SetDefaultColor(Color.LIGHT_ORANGE);
RLineP20.SetLineWeight(1);
RLineP20.HideBubble();
#####################################################################################
#####################################################################################

#End of Code#


# count_signals_00

def na = Double.NaN;
def bn = BarNumber();
#-----------------------
# test data
def x = Random() * 100;
input percent_of_test_signals = 20;
def t = (x <= percent_of_test_signals);
#-----------------------
# replace t,
# set desired signal variable equal to signal
def signal = gap1dn ;


#-----------------------
# signals on chart
def sig_cnt_chart = if bn == 1 and signal then 1
else if bn == 1 then 0
else if signal then sig_cnt_chart[1] + 1
else sig_cnt_chart[1];

addlabel(1, "quantity of Signal = True on chart " + sig_cnt_chart, color.yellow);

input show_signals_on_chart = yes;
def vert = 0.006;
plot z1 = if show_signals_on_chart and signal then high*(1+vert) else na;
z1.SetPaintingStrategy(PaintingStrategy.POINTS);
z1.SetDefaultColor(Color.cyan);
z1.setlineweight(2);
z1.hidebubble();

input show_signal_count_bubbles_on_chart = yes;
addchartbubble(show_signal_count_bubbles_on_chart and t, low*(1-vert),
 sig_cnt_chart
, color.yellow, no);
#

 

[Trigun1127]

Is it possible to have a signal 1 and a signal 2 where signal 2 is compared to signal 1 in terms of time until 2nd signal. I really liked your High of Day/Low of Day Array. It would be awesome to have an edit of this so that simple comparison over large data sets can made very quickly. For instance. When there are so many support lines in this code I don't know how I would identify signal 2 as being the close of Gap1up or Gap1dn. The information I would like collected would be things like this. Would each support line need to be entered in?
1. How many bars from signal 1 to signal 2
2. How many signal 1s on average per day
3. How many signal 2s on average per day
4. % chance if Signal 1 happens Signal 2 will happen.
5. % chance if signal 1 happens Signal 2 will happen on the same day
6. Of the % that does not happen on the same day what is the % chance it will happen on the next day or more.
7. Longest time from signal 1 to signal 2.

 

[halcyonguy]

Fantastic indicator! As an example Im confused what would be the signal for the close of either gap1up or gap1dn? I can use gap1up and gap1dn to determine their activations but Id like a seperate number that shows me how many of those closed

i came across this post today... sorry i didn't reply earlier.

i had to read it 6 times before it started to make sense, of what you are asking.
i was hung up on ' close of gap1up' . variables don't have a close price, they store 1 number per bar.
i tend to read things literally, i don't try to guess what someone means.

variables don't close. they have numbers or are true or false.
gaps can get filled, close

if you had said , count the filled gaps, that would make sense.

counting the price gaps that price later moves across ( filled, or closed )
https://centerpointsecurities.com/what-is-a-gap-fill-in-stocks/

------------------------------------

i don't know what counting gaps has to do with trying to plot 42 lines on a chart. 42 is a ridiculous amount of lines.
when creating a study, keep it simple.
for counting gaps, you only need the first 10 code lines. the other 500+ are just complicating things.

-----------------------------

to do this thoroughly, you would need to use arrays, but thinkscripts doesn't have arrays.
there will be a random number of gaps on a chart. and a random quantity of them that will be filled.
in order to count the filled gaps, you would need have,
. variables to save every gap range high and low.
. then compare those variables to all of the close prices, on all the bars after each gap.

something could be hard coded to look for a few , like 3 gaps. but if there are 6 gaps on the chart, then some data will missed and totals will be wrong.

 

[halcyonguy]

Fantastic indicator! As an example Im confused what would be the signal for the close of either gap1up or gap1dn? I can use gap1up and gap1dn to determine their activations but Id like a seperate number that shows me how many of those closed

this is an example of one way to look for filled gaps
the best way would be in another program and using arrays.


here is a study to look for 1 gap up and 1 gap down.
it draws lines from the gap
if the gap is filled, a bubble is drawn

there are 2 labels that count all the gaps on the chart

i added a setting, to specify a minimum price gap. default is 0.05.
without it, there were many gaps of 1/2 a penny or a penny

if you want to count more than 2 gaps, all this code will have to be copied and changed

# count_gaps_filled_00

#https://usethinkscript.com/threads/quantity-of-indicator-activations-for-thinkorswim.12890/#post-109# 790
#Trigun1127
#Oct 7, 2022
# count filled gaps ?


def na = Double.NaN;
def bn = BarNumber();

input min_gap = 0.05;

# originals
#def Gap1Up = open[0] > close[1] and close > open and close[1] > open[1];
#def Gap1Dn = open[0] < close[1] and close < open and close[1] < open[1];

# add a min price gap
#  without this, there are many 0.01 gaps
def GapUp1 = open[0] > (close[1] + min_gap) and close > open and close[1] > open[1];
def GapDn1 = open[0] < (close[1] - min_gap) and close < open and close[1] < open[1];

#----------------------
# count gaps
def cnt_Gap1Up = if bn == 1 then 0
  else if GapUp1 then cnt_Gap1Up[1] + 1
  else cnt_Gap1Up[1];

def cnt_Gap1dn = if bn == 1 then 0
  else if GapDn1 then cnt_Gap1dn[1] + 1
  else cnt_Gap1Dn[1];

AddLabel(1, "count Gap1Up " + cnt_Gap1Up , Color.YELLOW);
AddLabel(1, "count Gap1dn " + cnt_Gap1dn , Color.YELLOW);

#----------------------------

# check for gap fills on a gap up and a gap down

# set up variables as , trigger 1 time 
#  ex.  this line retains a value after a trigger
#    else if gapup1_hi[1] != 0 then gapup1_hi[1]

#--------------------
# gap ups  -  open[0] > close[1]

def gapup1_hi =
  if bn == 1 then 0
  else if gapup1_hi[1] != 0 then gapup1_hi[1]
  else if GapUp1 then open
  else gapup1_hi[1];


def gapup1_lo = 
  if bn == 1 then 0
  else if gapup1_lo[1] != 0 then gapup1_lo[1]
  else if GapUp1 then close[1]
  else gapup1_lo[1];

#--------------------
# gap downs   -  open[0] < close[1]

def gapdn1_hi =
  if bn == 1 then 0
  else if gapdn1_hi[1] != 0 then gapdn1_hi[1]
  else if GapDn1 then close[1]
  else gapdn1_hi[1];

def gapdn1_lo = 
  if bn == 1 then 0
  else if gapdn1_lo[1] != 0 then gapdn1_lo[1]
  else if Gapdn1 then open
  else gapdn1_lo[1];

#--------------------------

# gap up - filled
def gapup1_filled = 
  if bn == 1 then 0
  else if gapup1_filled[1] != 0 then gapup1_filled[1]
  else if gapup1_lo > 0 and close <= gapup1_lo then bn
  else gapup1_filled[1];

# gap down - filled
def gapdn1_filled = 
  if bn == 1 then 0
  else if gapdn1_filled[1] != 0 then gapdn1_filled[1]
  else if gapdn1_hi > 0 and close >= gapdn1_hi then bn
  else gapdn1_filled[1];

#--------------------

# gap lines
plot zgapup1_hi = if gapup1_hi > 0 then gapup1_hi else na;
plot zgapup1_lo = if gapup1_lo > 0 then gapup1_lo else na;
plot zgapdn1_hi = if gapdn1_hi > 0 then gapdn1_hi else na;
plot zgapdn1_lo = if gapdn1_lo > 0 then gapdn1_lo else na;

zgapup1_hi.SetDefaultColor(Color.green);
zgapup1_hi.hidebubble();
zgapup1_lo.SetDefaultColor(Color.green);
zgapup1_lo.hidebubble();

zgapdn1_hi.SetDefaultColor(Color.red);
zgapdn1_hi.hidebubble();
zgapdn1_lo.SetDefaultColor(Color.red);
zgapdn1_lo.hidebubble();

#---------------------

# gap up
addchartbubble(
(GapUp1 or gapup1_filled == bn),
high*1.001,
#(if gapup1 then "gap up" else if gapup1_filled == bn then "filled" else "") + "\n" +
(if gapup1_filled == bn then "filled\ngap up" else if gapup1 then "gap up" else "") + "\n" +
GapUp1 + "\n" +
gapup1_hi + "\n" +
gapup1_lo + "\n" +
gapup1_filled
, (if GapUp1 then color.green else if gapup1_filled == bn then color.cyan else color.gray), yes);


# gap down
addchartbubble(
(Gapdn1 or gapdn1_filled == bn),
low*0.998,
#(if gapdn1 then "gap down" else if gapdn1_filled == bn then "filled" else "") + "\n" +
(if gapdn1_filled == bn then "filled\ngap down" else if gapdn1 then "gap down" else "") + "\n" +
Gapdn1 + "\n" +
gapdn1_hi + "\n" +
gapdn1_lo + "\n" +
gapdn1_filled
, (if Gapdn1 then color.red else if gapdn1_filled == bn then color.yellow else color.gray), no);
#
#

IWM 5day 5min

 

[halcyonguy]

Is it possible to have a signal 1 and a signal 2 where signal 2 is compared to signal 1 in terms of time until 2nd signal. I really liked your High of Day/Low of Day Array. It would be awesome to have an edit of this so that simple comparison over large data sets can made very quickly. For instance. When there are so many support lines in this code I don't know how I would identify signal 2 as being the close of Gap1up or Gap1dn. The information I would like collected would be things like this. Would each support line need to be entered in?
1. How many bars from signal 1 to signal 2
2. How many signal 1s on average per day
3. How many signal 2s on average per day
4. % chance if Signal 1 happens Signal 2 will happen.
5. % chance if signal 1 happens Signal 2 will happen on the same day
6. Of the % that does not happen on the same day what is the % chance it will happen on the next day or more.
7. Longest time from signal 1 to signal 2.

first, trying to analyze 42 lines is silly. it's too many lines to be of any use.

are these data points to be collected daily? so at the start of each day the values would reset? then some of this is possible
some notes and sloppy code for you to study

1. How many bars from signal 1 to signal 2
compare barnumbers.
def diffday = if getday() != getday()[1] then 1 else 0;
def sig1bn = if diffday then 0
else if sig1 then barnumber()
else sig1bn[1];


2. How many signal 1s on average per day
count signals during day
when diffday is true add value at end of prev day to a variable
count the days
avg = total / qty of days


3. How many signal 2s on average per day
copy #2


4. % chance if Signal 1 happens Signal 2 will happen.
? compare the daily counts of signals , to get a ratio , a %. if it = 1 then they counts are equal.


5. % chance if signal 1 happens Signal 2 will happen on the same day
? compare counts


6. Of the % that does not happen on the same day what is the % chance it will happen on the next day or more.
too complicated


7. Longest time from signal 1 to signal 2.
time , just making it more complicated.
think in terms of how many bars.
( i know it can be converted to time, but it's just a number, the units don't matter. keep it simple)
make 2 other variables , to hold daily minimum and maximum of the barnumbers of each signal
subtract one from the other

 

[Trigun1127]

Appreciate this! will definitely study and play with it.