|
PureBytes Links
Trading Reference Links
|
Dude, that's a mountain of code you've cobbled together. Makes my head hurt looking at it. Maybe you
should start with something a bit simpler.. G
vin wrote:
> --- In amibroker@xxxxxxxxxxxxxxx, "vin" <vins1432000@xxx> wrote:
>
> i want to use this formula for eod for next day buy sell but i am
> getting problem how to work with this. also i want buy & sell alert
> with buy price & sell price along wth buy sell arrorowsin graph.
> kindly help me this formula in all level correct it if its wrong. also
> backtest, exploration, also create text alert for buy & sell signal
> genarates.
>
> formula is here
>
>
> // **************************
> // BEING EXPLORATION CODE
> // **************************
>
> // -- what will be our lookback range for the hh and ll?
> nBars = Param("Number of bars", 12, 5, 40);
> bTrace = Param("Include trace output", 1, 0, 1);
> nNoPivsInSetup = Param("No. Pivs in Setup", 4, 3, 4, 1);
> bShowTCZ = Param("Show TCZ", 1, 0, 1);
> nMinBarsBtwPivs = Param("Min. number of bars btw. pivots", 1, 1, 10, 1);
> nMinPctBtwPivs = Param("Min. percent diff. btw. pivots", .05, .04, .2,
> .01);
> bLastBarCanBePiv = Param("Last bar can be a pivot", 1, 0, 1);
> retrcTolerance = .01;
> tczTolerance = .005;
> nNumBarsToScan = 120;
>
> // -- added from exploration version 20040204
> nExploreBarIdx = 0;
> nExploreDate = 0;
> nCurDateNum = 0;
> DN = DateNum();
> DT = DateTime();
>
> // -- key exploration variables
> bTCZLong = Buy =False;
> bTCZShort = Sell =False;
> nAnchorPivIdx = 0;
>
> ADX8 = ADX(8);
>
> // 1 - INDICATOR, 2 - COMMENTARY, 3 - SCAN,
> // 4 - EXPLORATION, 5 - BACKTEST / Optimize
> if(Status("action")==1) {
> bDraw = True;
> bUseLastVis = Param("Use last visible bar", 1, 0, 1);
> } else {
> bDraw = False;
> bUseLastVis = False;
> bTrace = False;
> nExploreDate = Status("rangetodate");
> for (i=LastValue(BarIndex());i>=0;i--) {
> nCurDateNum = DN[i];
> if (nCurDateNum == nExploreDate) {
> nExploreBarIdx = i;
> }
> }
> // -- if(Status("action")==1...
> }
>
> GraphXSpace=7;
>
> // -- basic candle chart
> // -- if this appears inside if block, strange
> // drawing results!
> PlotOHLC(Open, High, Low, Close,
> "BIdx = " + BarIndex() +
> "\n" + "O = " + O + "\n"+"H = "+ H + "\n"+"L = " + L
> + "\n"+"C ",
> colorBlack, styleCandle);
>
> if (bDraw) {
> Plot(MA(C, 21), "21 bar MA", colorAqua,
> styleLine+styleNoRescale+styleNoLabel);
> Plot(MA(C, 55), "55 bar MA", colorGreen,
> styleLine+styleNoRescale+styleNoLabel);
> //Plot(MA(C, 233), "233 bar MA", colorDarkRed,
> // styleLine+styleNoRescale+styleNoLabel);
> }
>
> // -- Create 0-initialized arrays the size of barcount
> aHPivs = H - H;
> aLPivs = L - L;
> aHPivHighs = H - H;
> aLPivLows = L - L;
> aHPivIdxs = H - H;
> aLPivIdxs = L - L;
> aAddedHPivs = H - H;
> aAddedLPivs = L - L;
> aLegVol = H - H;
> aRetrcVol = H - H;
>
> nHPivs = 0;
> nLPivs = 0;
>
> lastHPIdx = 0;
> lastLPIdx = 0;
> lastHPH = 0;
> lastLPL = 0;
> curPivBarIdx = 0;
>
> // -- looking back from the current bar, how many bars
> // back were the hhv and llv values of the previous
> // n bars, etc.?
> aHHVBars = HHVBars(H, nBars);
> aLLVBars = LLVBars(L, nBars);
> aHHV = HHV(H, nBars);
> aLLV = LLV(L, nBars);
>
> // -- Initialize value of curTrend
> nLastVisBar = LastValue(
> Highest(IIf(Status("barvisible"), BarIndex(), 0)));
>
> curBar = IIf(nlastVisBar > 0 AND bUseLastVis, nlastVisBar,
> IIf(Status("action")==4 AND nExploreBarIdx > 0, nExploreBarIdx,
> LastValue(BarIndex())));
>
> curTrend = "";
> if (aLLVBars[curBar] < aHHVBars[curBar])
> curTrend = "D";
> else
> curTrend = "U";
>
> // -- Loop through bars. Search for
> // entirely array-based approach
> // in future version
> /* *******************
> Find main pivots
> ******************* */
>
> // -- Make sure there are enough bars!
> if (curBar >= nNumBarsToScan) {
> for (i=0; i<nNumBarsToScan; i++) {
>
> // -- value of curBar dependent on two parameters
> curBar = IIf(nlastVisBar > 0 AND bUseLastVis,
> nlastVisBar-i,
> IIf(Status("action")==4 AND nExploreBarIdx > 0,
> nExploreBarIdx-i,
> LastValue(BarIndex())-i));
>
> // -- Have we identified a pivot? If trend is down...
> if (aLLVBars[curBar] < aHHVBars[curBar]) {
>
> // ... and had been up, this is a trend change
> if (curTrend == "U") {
> curTrend = "D";
> // -- Capture pivot information
> curPivBarIdx = curBar - aLLVBars[curBar];
> aLPivs[curPivBarIdx] = 1;
> aLPivLows[nLPivs] = L[curPivBarIdx];
> aLPivIdxs[nLPivs] = curPivBarIdx;
> nLPivs++;
> }
> // -- or current trend is up
> } else {
> if (curTrend == "D") {
> curTrend = "U";
> curPivBarIdx = curBar - aHHVBars[curBar];
> aHPivs[curPivBarIdx] = 1;
> aHPivHighs[nHPivs] = H[curPivBarIdx];
> aHPivIdxs[nHPivs] = curPivBarIdx;
> nHPivs++;
> }
> // -- If curTrend is up...else...
> }
>
> // -- loop through bars
> }
> }
> /* *******************
> Found main pivots
> ******************* */
>
> /* *************************
> Finding missed pivot(s)
> ************************* */
>
> // -- Start at last bar. Reestablish curBar
> curBar =
> IIf(nlastVisBar > 0 AND bUseLastVis,
> nlastVisBar,
> IIf(Status("action")==4 AND nExploreBarIdx > 0,
> nExploreBarIdx,
> LastValue(BarIndex()))
> );
>
> // -- Make sure I found at least two of each above.
> if (nHPivs >= 2 AND nLPivs >= 2) {
>
> lastLPIdx = aLPivIdxs[0];
> lastLPL = aLPivLows[0];
>
> lastHPIdx = aHPivIdxs[0];
> lastHPH = aHPivHighs[0];
>
> nLastHOrLPivIdx = Max(lastLPIdx, lastHPIdx);
>
> nAddPivsRng = curBar - nLastHOrLPivIdx;
> aLLVAfterLastPiv = LLV(L, nAddPivsRng);
> nLLVAfterLastPiv = aLLVAfterLastPiv[curBar];
> aLLVIdxAfterLastPiv = LLVBars(L, nAddPivsRng);
> nLLVIdxAfterLastPiv = curBar - aLLVIdxAfterLastPiv[curBar];
> aHHVAfterLastPiv = HHV(H, nAddPivsRng);
> nHHVAfterLastPiv = aHHVAfterLastPiv[curBar];
> aHHVIdxAfterLastPiv = HHVBars(H, nAddPivsRng);
> nHHVIdxAfterLastPiv = curBar - aHHVIdxAfterLastPiv[curBar];
>
> // -- Later want to add last high pivot only if
> // not in buy mode from last and still in trade
>
> /*
> Note - I'm only interested in adding pivots if I'm in
> a higher-highs or lower-lows scenario
> */
>
>
> // -- OK, let's start where the last high pivot occurs after the
> // last Low pivot
> if (lastHPIdx > lastLPIdx) {
>
> /* There are at least two possibilities here. One is that
> the previous high was higher, indicating that this is a
> possible short retracement or one in the making.
> The other is that the previous high was lower, indicating
> that this is a possible long retracement in the working.
> However, both depend on opposing pivots. E.g., if I find
> higher highs, what if I have lower lows?
>
> If the highs are descending, then I can consider:
> - a lower low, and leave it at that
> - a higher high and higher low
> - a lower low and another lower high
> */
> if (aHPivHighs[0] < aHPivHighs[1]) {
>
> if (nLLVAfterLastPiv < aLPivLows[0] AND
> (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
> AND nLLVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aLPivs[nLLVIdxAfterLastPiv] = 1;
> aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nLPivs; j++) {
> aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
> aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
> }
> aLPivLows[0] = nLLVAfterLastPiv;
> aLPivIdxs[0] = nLLVIdxAfterLastPiv;
> nLPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> // -- Here, the last piv is a high piv, and we have
> // higher-highs. The most likely addition is a
> // Low piv that is a retracement.
> } else {
>
> if (nLLVAfterLastPiv > aLPivLows[0] AND
> (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
> AND nLLVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aLPivs[nLLVIdxAfterLastPiv] = 1;
> aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nLPivs; j++) {
> aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
> aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
> }
> aLPivLows[0] = nLLVAfterLastPiv;
> aLPivIdxs[0] = nLLVIdxAfterLastPiv;
> nLPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
> // -- The last piv is a high and we have higher highs
> // OR lower highs
> }
>
> /* ****************************************************************
> Still finding missed pivot(s). Here, the last piv is a low piv.
> **************************************************************** */
> } else {
>
> // -- First case, lower highs
> if (aHPivHighs[0] < aHPivHighs[1]) {
>
> if (nHHVAfterLastPiv < aHPivHighs[0] AND
> (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
> AND nHHVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark that for plotting
> aHPivs[nHHVIdxAfterLastPiv] = 1;
> aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nHPivs; j++) {
> aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
> aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
> }
> aHPivHighs[0] = nHHVAfterLastPiv;
> aHPivIdxs[0] = nHHVIdxAfterLastPiv;
> nHPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> // -- Second case when last piv is a low piv, higher highs
> // Most likely addition is high piv that is a retracement.
> // Considering adding a high piv as long as it is higher
> } else {
>
> // -- Where I have higher highs,
> if (nHHVAfterLastPiv > aHPivHighs[0] AND
> (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
> AND nHHVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aHPivs[nHHVIdxAfterLastPiv] = 1;
> aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nHPivs; j++) {
> aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
> aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
> }
> aHPivHighs[0] = nHHVAfterLastPiv;
> aHPivIdxs[0] = nHHVIdxAfterLastPiv;
> nHPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> }
>
> }
>
> // -- If there are at least two of each
> }
>
> /* ****************************************
> // -- Done with finding pivots
> ***************************************** */
>
> if (bDraw) {
>
> // -- OK, let's plot the pivots using arrows
> PlotShapes(
> IIf(aHPivs==1, shapeDownArrow, shapeNone),
> colorRed, 0, High, Offset=-15);
> PlotShapes(
> IIf(aAddedHPivs==1, shapeDownArrow, shapeNone),
> colorDarkRed, 0, High, Offset=-15);
> PlotShapes(
> IIf(aLPivs==1, shapeUpArrow , shapeNone),
> colorGreen, 0, Low, Offset=-15);
> PlotShapes(
> IIf(aAddedLPivs==1, shapeUpArrow , shapeNone),
> colorDarkGreen, 0, Low, Offset=-15);
> }
>
>
> /* ****************************************
> // -- Done with discovering and plotting pivots
> ***************************************** */
>
> // -- I'm going to want to look for possible retracement
> risk = 0;
> profInc = 0;
> nLeg0Pts = 0;
> nLeg0Bars = 0;
> nLeg0Vol = 0;
> nLeg1Pts = 0;
> nLeg1Bars = 0;
> nLeg1Vol = 0;
> nLegBarsDiff = 0;
> nRtrc0Pts = 0;
> nRtrc0Bars = 0;
> nRtrc0Vol = 0;
> nRtrc1Pts = 0;
> nRtrc1Bars = 0;
> nRtrc1Vol = 0;
>
> minRtrc = 0;
> maxRtrc = 0;
> minLine = 0;
> maxLine = 0;
> triggerLine = 0;
> firstProfitLine = 0;
> triggerInc = 0;
> triggerPrc = 0;
> firstProfitPrc = 0;
> retrcPrc = 0;
> retrcBar = 0;
> retrcBarIdx = 0;
> retrcRng = 0;
> aRetrcPrc = H-H;
> aRetrcPrcBars = H-H;
> aRetrcClose = C;
> retrcClose = 0;
>
> // -- Do TCZ calcs. Arrangement of pivs very specific
> // for this setup.
> if (nHPivs >= 2 AND
> nLPivs >=2 AND
> aHPivHighs[0] > aHPivHighs[1] AND
> aLPivLows[0] > aLPivLows[1]) {
>
> tcz500 =
> (aHPivHighs[0] -
> (.5 * (aHPivHighs[0] - aLPivLows[1])));
>
> tcz618 =
> (aHPivHighs[0] -
> (.618 * (aHPivHighs[0] - aLPivLows[1])));
>
> tcz786 =
> (aHPivHighs[0] -
> (.786 * (aHPivHighs[0] - aLPivLows[0])));
>
> retrcRng = curBar - aHPivIdxs[0];
> aRetrcPrc = LLV(L, retrcRng);
> retrcPrc = aRetrcPrc[curBar];
> aRetrcPrcBars = LLVBars(L, retrcRng);
> retrcBarIdx = curBar - aRetrcPrcBars[curBar];
> retrcClose = aRetrcClose[retrcBarIdx];
>
> // -- bTCZLong setup?
> bTCZLong = (
>
> // -- Are retracement levels arranged in
> // tcz order?
> tcz500 >= (tcz786 * (1 - tczTolerance))
> AND
> // .681 is below .786 for long setups
> tcz618 <= (tcz786 * (1 + tczTolerance))
> AND
>
> // -- Is the low in the tcz range
> // -- Is the close >= low of tcz range
> // and low <= high of tcz range
> retrcClose >= ((1 - retrcTolerance) * tcz618)
> AND
> retrcPrc <= ((1 + retrcTolerance) * tcz500)
> );
>
> // -- risk would be high of signal bar minus low of zone
> //risk = 0;
>
> // -- lower highs and lower lows
> } else if (nHPivs >= 2 AND nLPivs >=2
> AND aHPivHighs[0] < aHPivHighs[1]
> AND aLPivLows[0] < aLPivLows[1]) {
>
> tcz500 =
> (aHPivHighs[1] -
> (.5 * (aHPivHighs[1] - aLPivLows[0])));
>
> tcz618 =
> (aHPivHighs[0] -
> (.618 * (aHPivHighs[1] - aLPivLows[0])));
>
> tcz786 =
> (aHPivHighs[0] -
> (.786 * (aHPivHighs[0] - aLPivLows[0])));
>
> retrcRng = curBar - aLPivIdxs[0];
> aRetrcPrc = HHV(H, retrcRng);
> retrcPrc = aRetrcPrc[curBar];
> aRetrcPrcBars = HHVBars(H, retrcRng);
> retrcBarIdx = curBar - aRetrcPrcBars[curBar];
> retrcClose = aRetrcClose[retrcBarIdx];
>
> bTCZShort = (
> // -- Are retracement levels arranged in
> // tcz order?
>
> // .500 is below .786 for short setups
> tcz500 <= (tcz786 * (1 + tczTolerance))
> AND
> // .681 is above .786 for short setups
> tcz618 >= (tcz786 * (1 - tczTolerance))
> AND
>
> // -- Is the close <= high of tcz range
> // and high >= low of tcz range
> retrcClose <= ((1 + retrcTolerance) * tcz618)
> AND
> retrcPrc >= ((1 - retrcTolerance) * tcz500)
> );
>
> // -- Risk would be top of zone - low of signal bar
> //risk = 0;
> }
>
> Filter = (bTCZShort OR bTCZLong);
> AddColumn(C, "Close");
> AddColumn(IIf(bTCZLong, 76, 83), "L/S", formatChar);
>
> // **************************
> // END EXPLORATION CODE
> // **************************
>
> // **************************
> // BEGIN INDICATOR CODE
> // **************************
>
> // -- what will be our lookback range for the hh and ll?
> nBars = Param("Number of bars", 12, 5, 40);
> bTrace = Param("Include trace output", 1, 0, 1);
> nNoPivsInSetup = Param("No. Pivs in Setup", 4, 3, 4, 1);
> bShowTCZ = Param("Show TCZ", 1, 0, 1);
> nMinBarsBtwPivs = Param("Min. number of bars btw. pivots", 1, 1, 10, 1);
> nMinPctBtwPivs = Param("Min. percent diff. btw. pivots", .05, .04, .2,
> .01);
> bLastBarCanBePiv = Param("Last bar can be a pivot", 1, 0, 1);
> retrcTolerance = .01;
> tczTolerance = .005;
> nNumBarsToScan = 120;
>
> // -- added from exploration version 20040204
> nExploreBarIdx = 0;
> nExploreDate = 0;
> nCurDateNum = 0;
> DN = DateNum();
> DT = DateTime();
>
> // -- key exploration variables
> bTCZLong = Buy = False;
> bTCZShort = Sell = False;
> nAnchorPivIdx = 0;
>
> ADX8 = ADX(8);
>
> // 1 - INDICATOR, 2 - COMMENTARY, 3 - SCAN,
> // 4 - EXPLORATION, 5 - BACKTEST / Optimize
> if(Status("action")==1) {
> bDraw = True;
> bUseLastVis = Param("Use last visible bar", 1, 0, 1);
> } else {
> bDraw = False;
> bUseLastVis = False;
> bTrace = False;
> nExploreDate = Status("rangetodate");
> for (i=LastValue(BarIndex());i>=0;i--) {
> nCurDateNum = DN[i];
> if (nCurDateNum == nExploreDate) {
> nExploreBarIdx = i;
> }
> }
> // -- if(Status("action")==1...
> }
>
> GraphXSpace=7;
>
> // -- basic candle chart
> // -- if this appears inside if block, strange
> // drawing results!
> PlotOHLC(Open, High, Low, Close,
> "BIdx = " + BarIndex() +
> "\n" + "O = " + O + "\n"+"H = "+ H + "\n"+"L = " + L
> + "\n"+"C ",
> colorBlack, styleCandle);
>
> if (bDraw) {
> Plot(MA(C, 21), "21 bar MA", colorAqua,
> styleLine+styleNoRescale+styleNoLabel);
> Plot(MA(C, 55), "55 bar MA", colorGreen,
> styleLine+styleNoRescale+styleNoLabel);
> //Plot(MA(C, 233), "233 bar MA", colorDarkRed,
> // styleLine+styleNoRescale+styleNoLabel);
> }
>
> // -- Create 0-initialized arrays the size of barcount
> aHPivs = H - H;
> aLPivs = L - L;
> aHPivHighs = H - H;
> aLPivLows = L - L;
> aHPivIdxs = H - H;
> aLPivIdxs = L - L;
> aAddedHPivs = H - H;
> aAddedLPivs = L - L;
> aLegVol = H - H;
> aRetrcVol = H - H;
>
> nHPivs = 0;
> nLPivs = 0;
>
> lastHPIdx = 0;
> lastLPIdx = 0;
> lastHPH = 0;
> lastLPL = 0;
> curPivBarIdx = 0;
>
> // -- looking back from the current bar, how many bars
> // back were the hhv and llv values of the previous
> // n bars, etc.?
> aHHVBars = HHVBars(H, nBars);
> aLLVBars = LLVBars(L, nBars);
> aHHV = HHV(H, nBars);
> aLLV = LLV(L, nBars);
>
> // -- Initialize value of curTrend
> nLastVisBar = LastValue(
> Highest(IIf(Status("barvisible"), BarIndex(), 0)));
>
> curBar = IIf(nlastVisBar > 0 AND bUseLastVis, nlastVisBar,
> IIf(Status("action")==4 AND nExploreBarIdx > 0, nExploreBarIdx,
> LastValue(BarIndex())));
>
> curTrend = "";
> if (aLLVBars[curBar] < aHHVBars[curBar])
> curTrend = "D";
> else
> curTrend = "U";
>
> // -- Loop through bars. Search for
> // entirely array-based approach
> // in future version
> /* *******************
> Find main pivots
> ******************* */
>
> // -- Make sure there are enough bars!
> if (curBar >= nNumBarsToScan) {
> for (i=0; i<nNumBarsToScan; i++) {
>
> // -- value of curBar dependent on two parameters
> curBar = IIf(nlastVisBar > 0 AND bUseLastVis,
> nlastVisBar-i,
> IIf(Status("action")==4 AND nExploreBarIdx > 0,
> nExploreBarIdx-i,
> LastValue(BarIndex())-i));
>
> // -- Have we identified a pivot? If trend is down...
> if (aLLVBars[curBar] < aHHVBars[curBar]) {
>
> // ... and had been up, this is a trend change
> if (curTrend == "U") {
> curTrend = "D";
> // -- Capture pivot information
> curPivBarIdx = curBar - aLLVBars[curBar];
> aLPivs[curPivBarIdx] = 1;
> aLPivLows[nLPivs] = L[curPivBarIdx];
> aLPivIdxs[nLPivs] = curPivBarIdx;
> nLPivs++;
> }
> // -- or current trend is up
> } else {
> if (curTrend == "D") {
> curTrend = "U";
> curPivBarIdx = curBar - aHHVBars[curBar];
> aHPivs[curPivBarIdx] = 1;
> aHPivHighs[nHPivs] = H[curPivBarIdx];
> aHPivIdxs[nHPivs] = curPivBarIdx;
> nHPivs++;
> }
> // -- If curTrend is up...else...
> }
>
> // -- loop through bars
> }
> }
> /* *******************
> Found main pivots
> ******************* */
>
> /* *************************
> Finding missed pivot(s)
> ************************* */
>
> // -- Start at last bar. Reestablish curBar
> curBar =
> IIf(nlastVisBar > 0 AND bUseLastVis,
> nlastVisBar,
> IIf(Status("action")==4 AND nExploreBarIdx > 0,
> nExploreBarIdx,
> LastValue(BarIndex()))
> );
>
> // -- Make sure I found at least two of each above.
> if (nHPivs >= 2 AND nLPivs >= 2) {
>
> lastLPIdx = aLPivIdxs[0];
> lastLPL = aLPivLows[0];
>
> lastHPIdx = aHPivIdxs[0];
> lastHPH = aHPivHighs[0];
>
> nLastHOrLPivIdx = Max(lastLPIdx, lastHPIdx);
>
> nAddPivsRng = curBar - nLastHOrLPivIdx;
> aLLVAfterLastPiv = LLV(L, nAddPivsRng);
> nLLVAfterLastPiv = aLLVAfterLastPiv[curBar];
> aLLVIdxAfterLastPiv = LLVBars(L, nAddPivsRng);
> nLLVIdxAfterLastPiv = curBar - aLLVIdxAfterLastPiv[curBar];
> aHHVAfterLastPiv = HHV(H, nAddPivsRng);
> nHHVAfterLastPiv = aHHVAfterLastPiv[curBar];
> aHHVIdxAfterLastPiv = HHVBars(H, nAddPivsRng);
> nHHVIdxAfterLastPiv = curBar - aHHVIdxAfterLastPiv[curBar];
>
> // -- Later want to add last high pivot only if
> // not in buy mode from last and still in trade
>
> /*
> Note - I'm only interested in adding pivots if I'm in
> a higher-highs or lower-lows scenario
> */
>
>
> // -- OK, let's start where the last high pivot occurs after the
> // last Low pivot
> if (lastHPIdx > lastLPIdx) {
>
> /* There are at least two possibilities here. One is that
> the previous high was higher, indicating that this is a
> possible short retracement or one in the making.
> The other is that the previous high was lower, indicating
> that this is a possible long retracement in the working.
> However, both depend on opposing pivots. E.g., if I find
> higher highs, what if I have lower lows?
>
> If the highs are descending, then I can consider:
> - a lower low, and leave it at that
> - a higher high and higher low
> - a lower low and another lower high
> */
> if (aHPivHighs[0] < aHPivHighs[1]) {
>
> if (nLLVAfterLastPiv < aLPivLows[0] AND
> (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
> AND nLLVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aLPivs[nLLVIdxAfterLastPiv] = 1;
> aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nLPivs; j++) {
> aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
> aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
> }
> aLPivLows[0] = nLLVAfterLastPiv;
> aLPivIdxs[0] = nLLVIdxAfterLastPiv;
> nLPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> // -- Here, the last piv is a high piv, and we have
> // higher-highs. The most likely addition is a
> // Low piv that is a retracement.
> } else {
>
> if (nLLVAfterLastPiv > aLPivLows[0] AND
> (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
> AND nLLVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aLPivs[nLLVIdxAfterLastPiv] = 1;
> aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nLPivs; j++) {
> aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
> aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
> }
> aLPivLows[0] = nLLVAfterLastPiv;
> aLPivIdxs[0] = nLLVIdxAfterLastPiv;
> nLPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
> // -- The last piv is a high and we have higher highs
> // OR lower highs
> }
>
> /* ****************************************************************
> Still finding missed pivot(s). Here, the last piv is a low piv.
> **************************************************************** */
> } else {
>
> // -- First case, lower highs
> if (aHPivHighs[0] < aHPivHighs[1]) {
>
> if (nHHVAfterLastPiv < aHPivHighs[0] AND
> (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
> AND nHHVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark that for plotting
> aHPivs[nHHVIdxAfterLastPiv] = 1;
> aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nHPivs; j++) {
> aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
> aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
> }
> aHPivHighs[0] = nHHVAfterLastPiv;
> aHPivIdxs[0] = nHHVIdxAfterLastPiv;
> nHPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> // -- Second case when last piv is a low piv, higher highs
> // Most likely addition is high piv that is a retracement.
> // Considering adding a high piv as long as it is higher
> } else {
>
> // -- Where I have higher highs,
> if (nHHVAfterLastPiv > aHPivHighs[0] AND
> (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
> AND nHHVIdxAfterLastPiv != curBar ) {
>
> // -- OK, we'll add this as a pivot.
> // Mark it for plotting...
> aHPivs[nHHVIdxAfterLastPiv] = 1;
> aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
>
> // ...and then rearrange elements in the
> // pivot information arrays
> for (j=0; j<nHPivs; j++) {
> aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
> aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
> }
> aHPivHighs[0] = nHHVAfterLastPiv;
> aHPivIdxs[0] = nHHVIdxAfterLastPiv;
> nHPivs++;
>
> // -- Test whether to add piv given last piv is high
> // AND we have lower highs
> }
>
> }
>
> }
>
> // -- If there are at least two of each
> }
>
> /* ****************************************
> // -- Done with finding pivots
> ***************************************** */
>
> if (bDraw) {
>
> // -- OK, let's plot the pivots using arrows
> PlotShapes(
> IIf(aHPivs==1, shapeDownArrow, shapeNone),
> colorRed, 0, High, Offset=-15);
> PlotShapes(
> IIf(aAddedHPivs==1, shapeDownArrow, shapeNone),
> colorDarkRed, 0, High, Offset=-15);
> PlotShapes(
> IIf(aLPivs==1, shapeUpArrow , shapeNone),
> colorGreen, 0, Low, Offset=-15);
> PlotShapes(
> IIf(aAddedLPivs==1, shapeUpArrow , shapeNone),
> colorDarkGreen, 0, Low, Offset=-15);
> }
>
>
> /* ****************************************
> // -- Done with discovering and plotting pivots
> ***************************************** */
>
> // -- I'm going to want to look for possible retracement
> risk = 0;
> profInc = 0;
> nLeg0Pts = 0;
> nLeg0Bars = 0;
> nLeg0Vol = 0;
> nLeg1Pts = 0;
> nLeg1Bars = 0;
> nLeg1Vol = 0;
> nLegBarsDiff = 0;
> nRtrc0Pts = 0;
> nRtrc0Bars = 0;
> nRtrc0Vol = 0;
> nRtrc1Pts = 0;
> nRtrc1Bars = 0;
> nRtrc1Vol = 0;
>
> minRtrc = 0;
> maxRtrc = 0;
> minLine = 0;
> maxLine = 0;
> triggerLine = 0;
> firstProfitLine = 0;
> triggerInc = 0;
> triggerPrc = 0;
> firstProfitPrc = 0;
> retrcPrc = 0;
> retrcBar = 0;
> retrcBarIdx = 0;
> retrcRng = 0;
> aRetrcPrc = H-H;
> aRetrcPrcBars = H-H;
> aRetrcClose = C;
> retrcClose = 0;
>
> // -- Do TCZ calcs. Arrangement of pivs very specific
> // for this setup.
> if (nHPivs >= 2 AND
> nLPivs >=2 AND
> aHPivHighs[0] > aHPivHighs[1] AND
> aLPivLows[0] > aLPivLows[1]) {
>
> tcz500 =
> (aHPivHighs[0] -
> (.5 * (aHPivHighs[0] - aLPivLows[1])));
>
> tcz618 =
> (aHPivHighs[0] -
> (.618 * (aHPivHighs[0] - aLPivLows[1])));
>
> tcz786 =
> (aHPivHighs[0] -
> (.786 * (aHPivHighs[0] - aLPivLows[0])));
>
> retrcRng = curBar - aHPivIdxs[0];
> aRetrcPrc = LLV(L, retrcRng);
> aRetrcPrcBars = LLVBars(L, retrcRng);
>
> retrcPrc = aRetrcPrc[curBar];
> retrcBarIdx = curBar - aRetrcPrcBars[curBar];
> retrcClose = aRetrcClose[retrcBarIdx];
>
> // -- bTCZLong setup?
> bTCZLong = (
>
> // -- Are retracement levels arranged in
> // tcz order?
>
> // .500 is above .786 for long setups
> tcz500 >= (tcz786 * (1 - tczTolerance))
> AND
> // .681 is below .786 for long setups
> tcz618 <= (tcz786 * (1 + tczTolerance))
> AND
>
> // -- Is the low in the tcz range
> // -- Is the close >= low of tcz range
> // and low <= high of tcz range
> retrcClose >= ((1 - retrcTolerance) * tcz618)
> AND
> retrcPrc <= ((1 + retrcTolerance) * tcz500)
> );
>
> // -- risk would be high of signal bar minus low of zone
> //risk = 0;
>
> // -- lower highs and lower lows
> } else if (nHPivs >= 2 AND nLPivs >=2
> AND aHPivHighs[0] < aHPivHighs[1]
> AND aLPivLows[0] < aLPivLows[1]) {
>
> tcz500 =
> (aHPivHighs[1] -
> (.5 * (aHPivHighs[1] - aLPivLows[0])));
>
> tcz618 =
> (aHPivHighs[0] -
> (.618 * (aHPivHighs[1] - aLPivLows[0])));
>
> tcz786 =
> (aHPivHighs[0] -
> (.786 * (aHPivHighs[0] - aLPivLows[0])));
>
> retrcRng = curBar - aLPivIdxs[0];
> aRetrcPrc = HHV(H, retrcRng);
> retrcPrc = aRetrcPrc[curBar];
> aRetrcPrcBars = HHVBars(H, retrcRng);
> retrcBarIdx = curBar - aRetrcPrcBars[curBar];
> retrcClose = aRetrcClose[retrcBarIdx];
>
> bTCZShort = (
> // -- Are retracement levels arranged in
> // tcz order?
>
> // .500 is below .786 for short setups
> tcz500 <= (tcz786 * (1 + tczTolerance))
> AND
> // .681 is above .786 for short setups
> tcz618 >= (tcz786 * (1 - tczTolerance))
> AND
>
> // -- Is the close <= high of tcz range
> // and high >= low of tcz range
> retrcClose <= ((1 + retrcTolerance) * tcz618)
> AND
> retrcPrc >= ((1 - retrcTolerance) * tcz500)
> );
>
> // -- Risk would be top of zone - low of signal bar
> //risk = 0;
> }
>
> // -- Show zone if present
> if (bTCZShort OR bTCZLong) {
>
> // -- Be prepared to see symmetry
> if (bTCZShort) {
> if (aLPivIdxs[0] > aHPivIdxs[0]) {
> // -- Valuable, useful symmetry information
> nRtrc0Pts = aHPivHighs[0] - aLPivLows[1];
> nRtrc0Bars = aHPivIdxs[0] - aLPivIdxs[1] + 1;
> nRtrc1Pts = retrcPrc - aLPivLows[0];
> nRtrc1Bars = retrcBarIdx - aLPivIdxs[0] + 1;
> } else {
> nRtrc0Pts = aHPivHighs[1] - aLPivLows[1];
> nRtrc0Bars = aHPivIdxs[1] - aLPivIdxs[1] + 1;
> nRtrc1Pts = aHPivHighs[0] - aLPivLows[0];
> nRtrc1Bars = aHPivIdxs[0] - aLPivIdxs[0] + 1;
> }
> } else { // bLongSetup
> if (aLPivIdxs[0] > aHPivIdxs[0]) {
> nRtrc0Pts = aHPivHighs[0] - aLPivLows[1];
> nRtrc0Bars = aHPivIdxs[0] - aLPivIdxs[1] + 1;
> nRtrc1Pts = retrcPrc - aLPivLows[0];
> nRtrc1Bars = retrcBarIdx - aLPivIdxs[0] + 1;
> } else {
> nRtrc0Pts = aHPivHighs[1] - aLPivLows[0];
> nRtrc0Bars = aLPivIdxs[0] - aHPivIdxs[1] + 1;
> nRtrc1Pts = aHPivHighs[0] - aLPivLows[0];
> nRtrc1Bars = aLPivIdxs[0] - aHPivIdxs[0] + 1;
> }
> }
>
> if (bShowTCZ) {
> Plot(
> LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
> tcz500, curBar, tcz500 , 0),
> "tcz500", colorPaleBlue, styleLine);
> Plot(
> LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
> tcz618, curBar, tcz618, 0),
> "tcz618", colorPaleBlue, styleLine);
> Plot(
> LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
> tcz786, curBar, tcz786, 0),
> "tcz786", colorTurquoise, styleLine);
> }
>
> // -- if (bShowTCZ)
> }
>
> if (bDraw) {
> Title = Name() + " (" + StrLeft(FullName(), 10) +
> ") ATR: " + NumToStr(ATR(1), 4.2) + " ( " +
> NumToStr((C - Ref(C, -1)), 4.2) + " / " +
> NumToStr((((C - Ref(C, -1)) / Ref(C, -1)) * 100), 2.1) + "% ) " +
> WriteVal( SelectedValue( DateTime() ), formatDateTime) +
> " \nO: " + Open +
> ", \nH: " + High +
> ", \nL: " + Low +
> ", \nC: " + Close + ", \n" +
> // "Risk: " + WriteVal(risk, 2.1) + "% \n" +
> "Rtrc 0/1 Pts: " + WriteVal(nRtrc0Pts, 2.1) + "/" +
> WriteVal(nRtrc1Pts, 2.1) + " \n" +
> "Rtrc 0/1 Bars: " + WriteVal(nRtrc0Bars, 2.0) + "/" +
> WriteVal(nRtrc1Bars, 2.0);
> }
>
> // **************************
> // END INDICATOR CODE
> // **************************
>
> //Filter = (bTCZShort OR bTCZLong) AND C > $2 AND C < $20;
>
> Buy = Cover = Filter ;
> Sell = Short = aAddedHPivs;
> Buy = ExRem(Buy,Sell);
> Sell = ExRem(Sell,Buy);
> AddColumn(C, "Close");
> //AddColumn(IIf(bTCZLong, 76, 83), "L/S", formatChar);
>
> ////////////////////////
> num = Param("trend",3,1,6,1);
>
> FirstVisibleBar = Status( "FirstVisibleBar" );
> Lastvisiblebar = Status("LastVisibleBar");
>
> for( b = Firstvisiblebar + num; b <= Lastvisiblebar AND b < BarCount -
> num; b++)
> {
> i = num;
> ml = 0;
> mu = 0;
> while( i > 0 )
> {
> if (L[b] <= L[b-i] && L[b] <= L[b+i] )
> {
> ml++;
> }
> if (H[b] >= H[b-i] && H[b] >= H[b+i] )
> {
> mu++;
> }
> i--;
> }
> if ( ml == num )
> {
> PlotText("\n***\n",b,L[b],colorGreen);
> }
> if ( mu == num )
> {
> PlotText("***\n",b,H[b],colorRed);
> }
> }
>
> _SECTION_BEGIN("Alert Output As Quick Rewiev");
> //========================= QUICK VIEW [alert]
> =============================
> //==============================================================================
> //××× Period at finding changes at stocks price
> ××××××××××××××××××××××××××××
> x =-90;
> eDay =-1;
> eWeek =-5;
> eMonth =-20;
> eQTR =-60;
> eYEAR =-260;
> user =x;
> //××× HLEDANÁ DÉLKA
> ××××××××××××××××××××××××××××××××××××××××××××××××××××××××
> qvCAS = eDay; // There enter lenght period
> !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
> //××× PODMÍNKY
> ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
> qvCE =C;
> qvHLEDANE =Ref(C,qvCAS);
> qvBODY =qvCE-qvHLEDANE;
> qvPROCENTA =100*(qvCE-qvHLEDANE)/qvHLEDANE;
> //××× EXPLORE
> ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
> Filter = C;
> AddTextColumn(Name(),"Ticker",2, IIf( MarketID()==0,5,4));
> AddColumn(qvHLEDANE,"Prev.Price",1.2);
> AddColumn(C,"Price",1.2,IIf(C<1,11,IIf(C>=1 AND C<3,12,IIf(C>=3 AND
> C<20,1,0))));
> ;
> AddColumn(qvBODY,"Change in $",1.2,2
> ,IIf(qvBODY>=0.001,5,IIf(qvBODY==0,9,4 )));
> AddColumn(qvPROCENTA,"Change in %",1.2,2
> ,IIf(qvPROCENTA>=0.001,5,IIf(qvPROCENTA==0,9,4 )));//××× ALERT
> ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
> Buy = qvPROCENTA>0;
> Cover= qvProcenta==0;
> Sell = qvPROCENTA<0;
> AlertIf( Buy,"",WriteVal(qvPROCENTA,1.2),1,1,0 );
> AlertIf( Sell,"",WriteVal(qvPROCENTA,1.2),2,1,0 );
> AlertIf( Cover,"",WriteVal(qvPROCENTA,1.2),0,1,0 );
> //××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
>
> _SECTION_END();
>
> _SECTION_BEGIN("Application of Ehler filter");
> // ehler filter based on acclerartion and speed
> // x - input
> // n - length of FIR
> // w - exponential weight of passed acceleration and speed
> // f - weighting factor between acceleration and speed
> function Ehler1( x, V, n, w,f)
> {y=x;
> // acceleration + speed
> a = x-2*Ref(x,-1) + Ref(x,-2);
> s = f*(x-Ref(x,-1));
> q=AMA(V*(abs(a)+abs(s))/x,w);
>
> for( i = n-1; i < BarCount; i++ )
> {
> sy=0;sw=0;
> for (j=i-n+1; j<i+1; j++)
> {sy = sy + q[j]*x[j];
> sw = sw + q[j];
> }
> y[i]=sy/sw;
> }
> return y;
> }
> w=Param("w",0.62,0.05,0.99,0.01);
> n=Param("n",8,1,42,1);
> f=Param("f",-0.3,-10,10,0.1);
> f=10^f;
> eh=Ehler1(C,V,n,w,f);
> Plot( Close, "Price", colorBlack, styleCandle );
> Plot( eh, "Ehler", colorBlack );
> Plot( MA(C,n), "MA", colorBlue );
>
> _SECTION_END();
>
> _SECTION_BEGIN("ATR Study");
> //* ATR Study: */
>
> Exclude = MA(V,50)<200 ;
> MaxGraph = 12;
> Graph0 = C;
> Graph0Color = 1;
> Graph0Style = 64;
>
> BuyOffSet = 18;//Optimize("BuyOffSet",18,15,20,1);
> SellOffset = BuyOffSet;//Optimize("SellOffset",2,2,14,2);
> RegLength = 5;//Optimize("RegLength",5, 2,11,2);
> BuyATRPeriod = 2;//Optimize("BuyATRPeriod",2,2,5,1);
> SellATRPeriod = BuyATRPeriod;//Optimize("SellATRPeriod",4,2,11,2);
> ATRMultiplier = 1;//Optimize("ATRMultiplier",1,0.7,1.25,.05);
>
>
> Graph8 = HHV(H-ATRMultiplier*ATR(BuyATRPeriod),BuyOffset); /* RED */
> Graph9 = LLV(L+ATRMultiplier*ATR(SellATRPeriod),SellOffset); /* GREEN */
>
> Graph8Style=Graph9Style = 5;
> Graph9Color= 5; /* 5 is green */
> Graph8Color = 4; /* 4 is red */
>
> ticker = 0.0;//Optimize("Tickerk",0,0,1,0.125);
>
> Buy = Cover = Cross(C,Graph8) AND C>Graph9 AND LinRegSlope(EMA(C,17),2)>0;
> Sell = Short = Cross(Graph8,C) AND LinRegSlope(C,2)<0;
> Buy = ExRem(Buy,Sell);
> Sell = ExRem(Sell,Buy);
> BuyStop = Ref(Graph8,-1)+ ticker;
> BuyPrice = Max(BuyStop,Low);
> SellStop= Ref(Graph8,-1); //IIf(Cross(Graph8,C),Ref(Graph8,-1),0);
> SellPrice = Min( SellStop, High )- ticker;
>
> //ApplyStop(2,3,Optimize("TrailingStop",15,0,20,5),1);
>
> Filter= (Buy OR Sell) ;
> NumColumns = 8;
> Column0 = IIf(Buy==1,1,IIf(Sell==1,-1,0) );
> Column0Format = 1.0;
> Column0Name = "Long/Sell";
> Column1 = C;
> Column1Name = "Close ";
> Column1Format = 1.2;
> Column2 = MA(V,17);
> Column2Name = "17 Ma Vol ";
> Column2Format = 1.0;
> Column3 = MA(C,17)/MA(C,50);
> Column3Name = "% 17/50 ";
> Column3Format = 1.2;
> Column3Format = 1.2;
> Column4= MA(C,17);
> Column4Name="17 C ma";
> Column4Format = 1.2;
> Column5= MA(C,50);
> Column5Name="50 C ma";
> Column5Format = 1.2;
>
> Column6= BuyPrice;
> Column6Name="BuyPrice";
> Column6Format = 1.2;
> Column7= SellPrice;
> Column7Name="Sellprice";
> Column7Format = 1.2;
> _SECTION_END();
>
> _SECTION_BEGIN("Bull Fear _ Bear Fear");
> // BBFEAR.AFL v 0.001 24/01/2002
> // Bull Fear / Bear Fear with DX Trading System
> // Developed by Jef
> // Published in http://www.nt-tech.com.au/guppy/
> // Coded by Marek Chlopek, January 2002
>
>
> //
> ****************************************************************************************
> // INITIALIZATION OF EXPLORATION IN AMIBROKER
> //
> ****************************************************************************************
> Filter = 1;
> NumColumns = 5;
> Column0 = O; Column0Name = "O"; Column0Format = 1.2;
> Column1 = H; Column1Name = "H"; Column1Format = 1.2;
> Column2 = L; Column2Name = "L"; Column2Format = 1.2;
> Column3 = C; Column3Name = "C"; Column3Format = 1.2;
> Column4 = V; Column4Name = "V"; Column4Format = 1.0;
>
> // END OF "INITIALIZATION OF EXPLORATION IN AMIBROKER" SECTION
>
>
> //
> ****************************************************************************************
> // MAIN CODE
> //
> ****************************************************************************************
> Opt1 = Optimize("DX Level", 16, 10, 30, 1);
> Opt2 = Optimize("Period", 15, 10, 50, 1); // n
>
> n = Opt2;
> BullFear = (HHV(High,n) - LLV(High,n))/2 + LLV(High,n);
> BearFear = (HHV(Low,n) - LLV(Low,n))/2 + LLV(Low,n);
>
> // Exploration in Amibroker
> AddColumn(BullFear, "BullFear", format=1.2);
> AddColumn(BearFear, "BearFear", format=1.2);
>
> // END OF "MAIN CODE" SECTION
>
>
> //
> ****************************************************************************************
> // TRADING SYSTEM ENTRY FORMULAS
> //
> ****************************************************************************************
> Buy = Cover = Cross(Close, BullFear) AND ADX(10) > Opt1;
> Short = Sell = Cross(BearFear, Close);
>
> // Exploration in Amibroker
> AddColumn(Buy, "Buy", format=1.0);
> AddColumn(Short, "Short", format=1.0);
> //AddColumn(BuyPrice, "BuyPrice", format=1.2);
> //AddColumn(ShortPrice, "ShortPrice", format=1.2);
>
> // END OF "TRADING SYSTEM ENTRY FORMULAS" SECTION
>
>
> //
> ****************************************************************************************
> // TRADING SYSTEM EXIT FORMULAS
> //
> ****************************************************************************************
> Sell = Short;
> Cover = Buy;
>
> // Exploration in Amibroker
> AddColumn(Sell, "Sell", format=1.0);
> AddColumn(Cover, "Cover", format=1.0);
> //AddColumn(SellPrice, "SellPrice", format=1.2);
> //AddColumn(CoverPrice, "CoverPrice", format=1.2);
>
> // END OF "TRADING SYSTEM EXIT FORMULAS" SECTION
>
>
> //
> ****************************************************************************************
> // TRADING SYSTEM EXCESSIVE ENTRY/EXIT SIGNALS REMOVING FORMULAS
> //
> ****************************************************************************************
> Buy = ExRem(Buy, Sell);
> Sell = ExRem(Sell, Buy);
> Short = ExRem(Short, Cover);
> Cover = ExRem(Cover, Short);
>
> // END OF "TRADING SYSTEM EXCESSIVE ENTRY/EXIT SIGNALS REMOVING
> FORMULAS" SECTION
>
>
> //
> ****************************************************************************************
> // GRAPHIC PRESENTATION IN AMIBROKER
> //
> ****************************************************************************************
> MaxGraph = 3;
> Graph0 = C; Graph0Style = 4; Graph0Color = 1;
> Graph1 = BullFear; Graph1Style = 1; Graph1Color = 5;
> Graph2 = BearFear; Graph2Style = 1; Graph2Color = 4;
>
> Title = Name()
> + " - C (Black) = " + WriteVal(Graph0, 1.2)
> + ", BullFear (Green) = " + WriteVal(Graph1, 1.2)
> + ", BearFear (Red) = " + WriteVal(Graph2, 1.2);
>
> // END OF "GRAPHIC PRESENTATION IN AMIBROKER" SECTION
>
>
> //
> ****************************************************************************************
> // END OF CODE (BBFEAR.AFL)
> //
> ****************************************************************************************
> /**/
> _SECTION_END();
>
> _SECTION_BEGIN("Pivot Point and Support and Resistance Points");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Pivot Point and Support and Resistance Points
> // Author/Uploader: Anthony Faragasso
> // E-mail: ajf1111@xxx
> // Date/Time Added: 2002-04-25 09:04:53
> // Origin:
> // Keywords:
> // Level: basic
> // Flags: commentary
> // Formula URL: http://www.amibroker.com/library/formula.php?id=186
> // Details URL: http://www.amibroker.com/library/detail.php?id=186
> //
> //------------------------------------------------------------------------------
> //
> // Guru Commentary, provides Pivot and support and resistance
> //
> // points for the Next trading day.
> //
> //------------------------------------------------------------------------------
>
> /* Pivot points and Support and Resistance Points*/
> /* for next day trading*/
> /* coded by Anthony Faragasso */
>
>
> MaxGraph =8;
>
> p = (H+L+C)/3;
> r1 = (2*p)-L;
> s1 = (2*p)-H;
> r2 = p +(r1 - s1);
> s2 = p -(r2 - s1);
>
> Graph0=p;
> Graph1=r1;
> Graph2 = s1;
> Graph3= r2;
> Graph4 = s2;
>
> Graph0Style = Graph1Style = Graph2Style = Graph3Style = Graph4Style =
> 16 + 8;
> Graph0Color = 2;
> Graph1Color = Graph2Color = 8;
> Graph3Color = Graph4Color = 6;
>
> Graph5 = Close;
> Graph5Color = 3;
> Graph5Style = 128;
> "";
> "------------------------------------------------------------------------------------------------------------";
> " PIVOT POINTS AND SUPPORT AND RESISTANCE POINTS ";
> "------------------------------------------------------------------------------------------------------------";
> "";
> "MARKET BEING EVALUATED : " + Title = Name() + " DATE : " + Date();
> "";
> "TODAY'S CLOSE WAS : "+"( " +WriteVal(Close,format=1.2)+" )";
> "----------------------------------------------------------------------------------------------------------------------";
> " ******* THESE POINTS ARE VALID FOR NEXT TRADING DAY ******";
> "-----------------------------------------------------------------------------------------------------------------------";
> "RESISTENCE POINT 2 : ----------------" +WriteVal(Graph3,format=1.2);
> "";
> "RESISTENCE POINT 1 : ----------------" +WriteVal(Graph1,format=1.2);
> "";
> " --------------------------------------------------------"+
> "("+WriteVal(Graph0,format=1.2)+")" +" PIVOT POINT--------";
> "";
> "SUPPORT POINT 1 : ----------------------" +WriteVal(Graph2,format=1.2);
> "";
> "SUPPORT POINT 2 : ----------------------" +WriteVal(Graph4,format=1.2);
> _SECTION_END();
>
> _SECTION_BEGIN("Auto Analysis Key Reversal");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Auto Analysis Key Reversal
> // Author/Uploader: Larry Lovrencic
> // E-mail: lvl@xxx
> // Date/Time Added: 2001-09-04 01:51:44
> // Origin:
> // Keywords: key reversal automatic analysis
> // Level: basic
> // Flags: exploration
> // Formula URL: http://www.amibroker.com/library/formula.php?id=109
> // Details URL: http://www.amibroker.com/library/detail.php?id=109
> //
> //------------------------------------------------------------------------------
> //
> // Find Key Reversals using automatic analysis
> //
> //------------------------------------------------------------------------------
>
> /*Key Reversals Automatic Analysis
> by Larry Lovrencic*/
>
> Buy=O<Ref(C,-1) AND L<Ref(L,-1) AND C>Ref(H,-1);
> Sell=O>Ref(C,-1) AND H>Ref(H,-1) AND C<Ref(L,-1);
> _SECTION_END();
>
> _SECTION_BEGIN("Positive ROC Exploration");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Positive ROC Exploration
> // Author/Uploader: Mubashar Virk
> // E-mail: mavirk@xxx
> // Date/Time Added: 2006-10-03 14:36:47
> // Origin: ROC
> // Keywords: ROC
> // Level: basic
> // Flags: exploration
> // Formula URL: http://www.amibroker.com/library/formula.php?id=730
> // Details URL: http://www.amibroker.com/library/detail.php?id=730
> //
> //------------------------------------------------------------------------------
> //
> // Hi there guys and ladies, I have a Positive ROC exploration for
> all you
> // tight-traders and beginners. It may give you some good picks for
> the next
> // day. Needless to say you must study the securities by using William,
> // Chaikin, and Bollinger's. Also try to put your own filtration
> values for
> // ROC and Volume as mine are too tight. May the Profit be with you all.
> //
> //------------------------------------------------------------------------------
>
> P = ((H + L + C) / 3);
> R1 = ((2 * P) - L);
> S1 = ((2 * P) - H);
> R2 = ((P - S1) + R1);
> S2 = (P - (R1 - S1));
>
> Filter = ROC( C, 1 ) > 0.25 AND V > 29999;
>
> AddColumn( V, "Volume",1 );
> AddColumn( C, "Close" );
> AddColumn( Ref (C, -1), "Last Close");
> AddColumn( C - Ref( C, -1), "Change");
> AddColumn( ROC( C, 1 ), "ROC" );
> AddColumn (RSI(), "RSI",1.2);
> AddColumn( r2, "R 2", 1.2);
> AddColumn( r1, "R 1", 1.2);
> AddColumn( P, "Pivot", 1.2);
> AddColumn( S1, "S 1", 1.2);
> AddColumn( S2, "S 2", 1.2);
> _SECTION_END();
>
> _SECTION_BEGIN("Price Persistency");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Price Persistency
> // Author/Uploader: Anthony Faragasso
> // E-mail: ajf1111@xxx
> // Date/Time Added: 2002-12-29 18:20:39
> // Origin:
> // Keywords:
> // Level: basic
> // Flags: exploration
> // Formula URL: http://www.amibroker.com/library/formula.php?id=245
> // Details URL: http://www.amibroker.com/library/detail.php?id=245
> //
> //------------------------------------------------------------------------------
> //
> // Interested in measuring a short-term Trend ?
> //
> // Price persistency is the number of days that a market continues to
> close
> // either up or down. It's another term for a market run. The
> usefulness of
> // Price Persistency is based on the theory of runs..It is the idea that,
> // given the market has moved in a particular direction for ( n )
> days, the
> // likelihood it will either continue..or not...can be estimated and
> used in a
> // profitable trading system....
> //
> //------------------------------------------------------------------------------
>
> //Price Persistency Exploration
> //Interpreted from January,2002, TASC, page 44
> //article by Gordon Gustafson on Price Persistency
> //Coded by Anthony Faragasso, 12/31/01
> //Version 1.00
>
> /*****Bars in the test*****************/
> bars=Cum(1);
> /**************************************/
> Day1up=C > Ref(C,-1);
> Day1Dn=C < Ref(C,-1);
> /**************************************/
>
> Day2up=C > Ref(C,-1) AND Ref(C,-1) > Ref(C,-2);
> Day2Dn=C < Ref(C,-1) AND Ref(C,-1) < Ref(C,-2);
>
> /***********************************************/
> Day3up=C > Ref(C,-1) AND Ref(C,-1) > Ref(C,-2) AND Ref(C,-2) > Ref(C,-3);
> Day3Dn=C < Ref(C,-1) AND Ref(C,-1) < Ref(C,-2) AND Ref(C,-2) < Ref(C,-3);
> /**********************************************/
>
> Day4up=C > Ref(C,-1) AND Ref(C,-1)>Ref(C,-2)AND Ref(C,-2)>Ref(C,-3)
> AND Ref(C,-3) > Ref(C,-4);
> Day4Dn=C < Ref(C,-1) AND Ref(C,-1)<Ref(C,-2)AND Ref(C,-2)<Ref(C,-3)
> AND Ref(C,-3) < Ref(C,-4);
> /**********************************************/
>
> Day5up=C > Ref(C,-1) AND Ref(C,-1)>Ref(C,-2)AND Ref(C,-2)>Ref(C,-3)AND
> Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) > Ref(C,-5);
> Day5Dn=C < Ref(C,-1) AND Ref(C,-1)<Ref(C,-2)AND Ref(C,-2)<Ref(C,-3)AND
> Ref(C,-3) < Ref(C,-4) AND Ref(C,-4) < Ref(C,-5);
> /************************************************/
>
> Day6up=C > Ref(C,-1) AND Ref(C,-1)> Ref(C,-2)AND
> Ref(C,-2)>Ref(C,-3)AND Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) > Ref(C,-5)
> AND Ref(C,-5) > Ref(C,-6);
> Day6Dn=C < Ref(C,-1) AND Ref(C,-1)< Ref(C,-2)AND Ref(C,-2)<
> Ref(C,-3)AND Ref(C,-3) < Ref(C,-4)AND Ref(C,-4) < Ref(C,-5) AND
> Ref(C,-5) < Ref(C,-6);
> /***********************************************/
>
> Day7up=C > Ref(C,-1) AND Ref(C,-1)> Ref(C,-2)AND
> Ref(C,-2)>Ref(C,-3)AND Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) >
> Ref(C,-5)AND Ref(C,-5)>Ref(C,-6) AND Ref(C,-6) > Ref(C,-7);
> Day7Dn=C < Ref(C,-1) AND Ref(C,-1)< Ref(C,-2)AND Ref(C,-2)<
> Ref(C,-3)AND Ref(C,-3) < Ref(C,-4)AND Ref(C,-4) < Ref(C,-5)AND
> Ref(C,-5)< Ref(C,-6)AND Ref(C,-6) < Ref(C,-7);
> /*********************************************/
>
> Day8up=C > Ref(C,-1) AND Ref(C,-1)> Ref(C,-2)AND
> Ref(C,-2)>Ref(C,-3)AND Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) >
> Ref(C,-5)AND Ref(C,-5)>Ref(C,-6)AND Ref(C,-6) > Ref(C,-7) AND
> Ref(C,-7) > Ref(C,-8);
> Day8Dn=C < Ref(C,-1) AND Ref(C,-1)< Ref(C,-2)AND Ref(C,-2)<
> Ref(C,-3)AND Ref(C,-3) < Ref(C,-4)AND Ref(C,-4) < Ref(C,-5)AND
> Ref(C,-5)< Ref(C,-6)AND Ref(C,-6) < Ref(C,-7)AND Ref(C,-7) < Ref(C,-8);
> /**********************************************/
>
> Day9up=C > Ref(C,-1) AND Ref(C,-1)> Ref(C,-2)AND
> Ref(C,-2)>Ref(C,-3)AND Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) >
> Ref(C,-5)AND Ref(C,-5)>Ref(C,-6)AND Ref(C,-6) > Ref(C,-7)AND Ref(C,-7)
>> Ref(C,-8) AND Ref(C,-8) > Ref(C,-9);
> Day9Dn=C < Ref(C,-1) AND Ref(C,-1)< Ref(C,-2)AND Ref(C,-2)<
> Ref(C,-3)AND Ref(C,-3) < Ref(C,-4)AND Ref(C,-4) < Ref(C,-5)AND
> Ref(C,-5)< Ref(C,-6)AND Ref(C,-6) < Ref(C,-7)AND Ref(C,-7) < Ref(C,-8)
> AND Ref(C,-8) < Ref(C,-9);
> /**********************************************/
>
> Day10up=C > Ref(C,-1) AND Ref(C,-1)> Ref(C,-2)AND
> Ref(C,-2)>Ref(C,-3)AND Ref(C,-3) > Ref(C,-4) AND Ref(C,-4) >
> Ref(C,-5)AND Ref(C,-5)>Ref(C,-6)AND Ref(C,-6) > Ref(C,-7)AND Ref(C,-7)
>> Ref(C,-8)AND Ref(C,-8)> Ref(C,-9) AND Ref(C,-9) > Ref(C,-10);
> Day10Dn=C < Ref(C,-1) AND Ref(C,-1)< Ref(C,-2)AND Ref(C,-2)<
> Ref(C,-3)AND Ref(C,-3) < Ref(C,-4)AND Ref(C,-4) < Ref(C,-5)AND
> Ref(C,-5)< Ref(C,-6)AND Ref(C,-6) < Ref(C,-7)AND Ref(C,-7) <
> Ref(C,-8)AND Ref(C,-8) < Ref(C,-9) AND Ref(C,-9) < Ref(C,-10);
> /************************************************/
>
> tot1dayUp=LastValue(Cum(Day1up));tot1dayDn=LastValue(Cum(Day1Dn));
> tot2dayUp=LastValue(Cum(Day2up));tot2dayDn=LastValue(Cum(Day2Dn));
> tot3dayUp=LastValue(Cum(Day3up));tot3dayDn=LastValue(Cum(Day3Dn));
> tot4dayUp=LastValue(Cum(Day4up));tot4dayDn=LastValue(Cum(Day4Dn));
> tot5dayUp=LastValue(Cum(Day5up));tot5dayDn=LastValue(Cum(Day5Dn));
> tot6dayUp=LastValue(Cum(Day6up));tot6dayDn=LastValue(Cum(Day6Dn));
> tot7dayUp=LastValue(Cum(Day7up));tot7dayDn=LastValue(Cum(Day7Dn));
> tot8dayUp=LastValue(Cum(Day8up));tot8dayDn=LastValue(Cum(Day8Dn));
> tot9dayUp=LastValue(Cum(Day9up));tot9dayDn=LastValue(Cum(Day9Dn));
> tot10dayUp=LastValue(Cum(Day10up));tot10dayDn=LastValue(Cum(Day10Dn));
>
> /*********Percentages for Up or Down as a % of total bars *************/
> totpct1dayup=tot1dayUp/(Cum(1))*100;
> totpct1dayDn=tot1dayDn/(Cum(1))*100;
> totpct2dayUp=tot2dayUp/(Cum(1))*100;
> totpct2dayDn=tot2dayDn/(Cum(1))*100;
> totpct3dayUp=tot3dayUp/(Cum(1))*100;
> totpct3dayDn=tot3dayDn/(Cum(1))*100;
> totpct4dayUp=tot4dayUp/(Cum(1))*100;
> totpct4dayDn=tot4dayDn/(Cum(1))*100;
> totpct5dayUp=tot5dayUp/(Cum(1))*100;
> totpct5dayDn=tot5dayDn/(Cum(1))*100;
> totpct6dayUp=tot6dayUp/(Cum(1))*100;
> totpct6dayDn=tot6dayDn/(Cum(1))*100;
> totpct7dayUp=tot7dayUp/(Cum(1))*100;
> totpct7dayDn=tot7dayDn/(Cum(1))*100;
> totpct8dayUp=tot8dayUp/(Cum(1))*100;
> totpct8dayDn=tot8dayDn/(Cum(1))*100;
> totpct9dayUp=tot9dayUp/(Cum(1))*100;
> totpct9dayDn=tot9dayDn/(Cum(1))*100;
> totpct10dayUp=tot10dayUp/(Cum(1))*100;
> totpct10dayDn=tot10dayDn/(Cum(1))*100;
>
> /*******************************************************/
> /**********Percent up or down / previous up or
> down***********************/
>
> Pct2dayUp=(tot2dayUp/tot1dayup)*100;
> Pct2dayDn=(tot2dayDn/tot1dayDn)*100;
> pct3dayUp=(tot3dayUp/tot2dayup)*100;
> pct3dayDn=(tot3dayDn/tot2dayDn)*100;
> pct4dayUp=(tot4dayUp/tot3dayUp)*100;
> pct4dayDn=(tot4dayDn/tot3dayDn)*100;
> pct5dayUp=(tot5dayUp/tot4dayUp)*100;
> pct5dayDn=(tot5dayDn/tot4dayDn)*100;
> pct6dayUp=(tot6dayUp/tot5dayUp)*100;
> pct6dayDn=(tot6dayDn/tot5dayDn)*100;
> pct7dayUp=(tot7dayUp/tot6dayUp)*100;
> pct7dayDn=(tot7dayDn/tot6dayDn)*100;
> pct8dayUp=(tot8dayUp/tot7dayUp)*100;
> pct8dayDn=(tot8dayDn/tot7dayDn)*100;
> pct9dayUp=(tot9dayUp/tot8dayUp)*100;
> pct9dayDn=(tot9dayDn/tot8dayDn)*100;
> pct10dayUp=(tot10dayUp/tot9dayUp)*100;
> pct10dayDn=(tot10dayDn/tot9dayDn)*100;
>
>
> Filter=1;
> /***Current State of the Closes******/
> stateUp=BarsSince(C < Ref(C,-1));
> stateDown=BarsSince(C > Ref(C,-1));
> AddColumn(stateUp,"currentUp");
> AddColumn(statedown,"CurrentDown");
>
> /***Close is equal to previous close*****/
> AddColumn(Cum(C == Ref(C,-1)),"Close==PrevClose",1);
>
> /***Days in a row ,whether up or down ( A Run )********/
> //1 day
>
> AddColumn(tot1dayUp,"1dayUp",1);AddColumn(tot1dayDn,"1dayDn",1);AddColumn(0,"%Up/PrevUp");AddColumn(0,"%Dn/PrevDn");AddColumn(totpct1dayUp,"%Up[bars]");AddColumn(totpct1dayDn,"%Dn[bars]");
> //2 days
> AddColumn(tot2dayUp,"2dayUp",1);AddColumn(tot2dayDn,"2dayDn",1);AddColumn(pct2dayUp,"%Up/prevUp");AddColumn(pct2dayDn,"%Dn/prevDn");AddColumn(totpct2dayUp,"%Up[bars]");AddColumn(totpct2dayDn,"%Dn[bars]");
> //3 days
> AddColumn(tot3dayUp,"3dayUp",1);AddColumn(tot3dayDn,"3dayDn",1);AddColumn(pct3dayUp,"%Up/prevUp");AddColumn(pct3dayDn,"%Dn/prevDn");AddColumn(totpct3dayUp,"%Up[bars]");AddColumn(totpct3dayDn,"%Dn[bars]");
> //4 days
> AddColumn(tot4dayUp,"4dayUp",1);AddColumn(tot4dayDn,"4dayDn",1);AddColumn(pct4dayup,"%Up/prevUp");AddColumn(pct4dayDn,"%Dn/prevDn");AddColumn(totpct4dayUp,"%Up[bars]");AddColumn(totpct4dayDn,"%Dn[bars]");
> //5 days
> AddColumn(tot5dayUp,"5dayUp",1);AddColumn(tot5dayDn,"5dayDn",1);AddColumn(pct5dayup,"%Up/prevUp");AddColumn(pct5dayDn,"%Dn/prevDn");AddColumn(totpct5dayUp,"%Up[bars]");AddColumn(totpct5dayDn,"%Dn[bars]");
> //6 days
> AddColumn(tot6dayUp,"6dayUp",1);AddColumn(tot6dayDn,"6dayDn",1);AddColumn(pct6dayUp,"%Up/prevUp");AddColumn(pct6dayDn,"%Dn/prevDn");AddColumn(totpct6dayUp,"%Up[bars]");AddColumn(totpct6dayDn,"%Dn[bars]");
> //7 days
> AddColumn(tot7dayUp,"7dayUp",1);AddColumn(tot7dayDn,"7dayDn",1);AddColumn(pct7dayUp,"%Up/prevUp");AddColumn(pct7dayDn,"%Dn/prevDn");AddColumn(totpct7dayUp,"%Up[bars]");AddColumn(totpct7dayDn,"%Dn[bars]");
> //8 days
> AddColumn(tot8dayUp,"8dayUp",1);AddColumn(tot8dayDn,"8dayDn",1);AddColumn(pct8dayUp,"%Up/prevUp");AddColumn(pct8dayDn,"%Dn/PrevDn");AddColumn(totpct8dayUp,"%Up[bars]");AddColumn(totpct8dayDn,"%Dn[bars]");
> //9 days
> AddColumn(tot9dayUp,"9dayUp",1);AddColumn(tot9dayDn,"9dayDn",1);AddColumn(pct9dayUp,"%Up/prevUp");AddColumn(pct9dayDn,"%Dn/prevDn");AddColumn(totpct9dayUp,"%Up[bars]");AddColumn(totpct9dayDn,"%Dn[bars]");
> //10 days
> AddColumn(tot10dayUp,"10dayUp",1);AddColumn(tot10dayDn,"10dayDn",1);AddColumn(pct10dayUp,"%Up/prevUp");AddColumn(pct10dayDn,"%Dn/prevDn");AddColumn(totpct10dayUp,"%Up[bars]");AddColumn(totpct10dayDn,"%Dn[bars]");
>
> AddColumn(bars,"bars",1);
> _SECTION_END();
>
> _SECTION_BEGIN("Trend exploration with multiple timeframes");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Trend exploration with multiple timeframes
> // Author/Uploader: Marcus Davidsson
> // E-mail: davidsson_marcus@xxx
> // Date/Time Added: 2006-09-30 20:31:21
> // Origin:
> // Keywords: exploration, trend, moving average
> // Level: medium
> // Flags: exploration
> // Formula URL: http://www.amibroker.com/library/formula.php?id=724
> // Details URL: http://www.amibroker.com/library/detail.php?id=724
> //
> //------------------------------------------------------------------------------
> //
> // I started experimenting with Tradestations Radarscreen
> //
> // when it struck me that Amibroker have the same function
> "Exploration" but
> // 100000$ much cheaper.
> //
> // The formula is quite simple just load it in to Amibroker
> //
> // and go to automatic analysis and push explore.
> //
> // The formula will scan multiple moving averages and draw conclusions
> // regarding overall trend phase, strenght etc. Enjoy!
> //
> //------------------------------------------------------------------------------
>
> /*Use daily data! You could use data with
> higher time resolution but then you have
> to include a timeframe parameters
> since 10 periods will become
> 10 minutes (if you have one Minute data)*/
>
> //////////////////////////////////////////////////////////////
>
> Filter = 1; // all symbols and quotes accepted.
> DTL=140; // DTL = Define Trend Long
> DTM=60; // DTM = Define Trend Medium
> DTS=8; // DTS = Define Trend Short
>
> //////////////////////////////////////////////////////////////
>
> TL=LinRegSlope(MA(C, DTL),2); // TL = Trend Long
> TM=LinRegSlope(MA(C, DTM),2); // TM = Trend Medium
> TS=LinRegSlope(MA(C, DTS),2); // TS = Trend Short
>
> TLL=IIf(LinRegSlope(MA(C, DTL),2) > 0,True, False);
> TMM=IIf(LinRegSlope(MA(C, DTM),2) > 0,True, False);
> TSS=IIf(LinRegSlope(MA(C, DTS),2) > 0,True, False);
>
> TLLL=
> WriteIf(TL>0 AND TL<0.3,"+",
> WriteIf(TL>=0.3 AND TL<0.6 ,"+ +",
> WriteIf(TL>=0.6,"+ + +",
> WriteIf(TL<0 AND TL>-0.3,"-",
> WriteIf(TL<=-0.3 AND TL>-0.6 ,"- -",
> WriteIf(TL<=-0.6,"- - -",""))))));
>
> TMMM=
> WriteIf(TM>0 AND TM<0.3,"+",
> WriteIf(TM>=0.3 AND TM<0.6 ,"+ +",
> WriteIf(TM>=0.6,"+ + +",
> WriteIf(TM<0 AND TM>-0.3,"-",
> WriteIf(TM<=-0.3 AND TM>-0.6 ,"- -",
> WriteIf(TM<=-0.6,"- - -",""))))));
>
> TSSS=
> WriteIf(TS>0 AND TS<0.3,"+",
> WriteIf(TS>=0.3 AND TS<0.6 ,"+ +",
> WriteIf(TS>=0.6,"+ + +",
> WriteIf(TS<0 AND TS>-0.3,"-",
> WriteIf(TS<=-0.3 AND TS>-0.6 ,"- -",
> WriteIf(TS<=-0.6,"- - -",""))))));
>
> //////////////////////////////////////////////////////////////
>
> AddTextColumn( TLLL, "MA"+-DTL, 1 , colorDefault,
> IIf( TLL==True, colorGreen, colorRed ),-1 );
> AddTextColumn( TMMM, "MA"+-DTM, 1 , colorDefault,
> IIf( TMM==True, colorGreen, colorRed ),-1 );
> AddTextColumn( TSSS, "MA"+-DTS, 1 , colorDefault,
> IIf( TSS==True, colorGreen, colorRed ),-1 );
>
> //////////////////////////////////////////////////////////////
> message=
> WriteIf(TL>=0.3 AND TM>=0.3 AND
> TS>=0.3, "Strong Up Trend",
> WriteIf(TL<=-0.3 AND TM<=-0.3 AND
> TS<=-0.3, "Strong Down Trend",
> WriteIf(TLL==True AND TMM==True AND
> TSS==True,"Up Trend",
> WriteIf(TLL==False AND TMM==False AND
> TSS==False,"Down Trend", "No Trend"))));
>
>
> AddTextColumn( message, "Overall Trend", 1 ,
> colorDefault,IIf(TLL==True AND TMM==True AND
> TSS==True, colorGreen,
> IIf(TLL==False AND TMM==False AND
> TSS==False, colorRed, colorDefault )),-1 );
>
> //////////////////////////////////////////////////////////////
>
> x = IIf(Cross(LinRegSlope(MA(C, DTL),2),0) OR
> Cross(0, LinRegSlope(MA(C, DTL),2) ), True, False);
> y = BarIndex()-ValueWhen(x==True, BarIndex(),1);
>
> Phase=WriteIf(Y>=400,"Mature",WriteIf(Y>100 AND
> Y<400, "Progress", WriteIf(Y<=100, "Initial", "")));
> //AddColumn( y, "Trend Phase", 1 , colorDefault, -1);
> AddTextColumn( Phase, "Trend Phase", 1 , colorDefault, -1);
>
> //////////////////////////////////////////////////////////////
> Comments=
> WriteIf(Y>=400,"Mature trend with risk of bubble",
> WriteIf(y<400 AND TLL==True AND TMM==True AND TSS==True,
> "Keep on coming baby $",
> WriteIf(y<15 AND TLL==True AND TMM==True AND TSS==True OR
> TLL==False AND TMM==False AND TSS==False,
> "Are you going to grow up and become a big boy?",
> WriteIf(y<400 AND TLL==False AND TMM==False AND TSS==False,
> "Keep on coming baby $$",
> WriteIf(TLL==True AND TMM==True AND TSS==False OR
> TLL==False AND TMM==False AND TSS==True,
> "Risk for short term reversal",
> WriteIf(TLL==True AND TMM==False AND TSS==True OR
> TLL==False AND TMM==True AND TSS==False,
> "trading range-avoid",
> "live to trade another day"))))));
>
> AddTextColumn( Comments, "Comments", 1 ,
> colorDefault,colorDefault,-1 );
>
>
> //////////////////////////////////////////////////////////////
> _SECTION_END();
>
> //------------------------------------------------------------------------------
> //
> // Formula Name: Auto-Optimization Framework
> // Author/Uploader: Dave Merrill
> // E-mail:
> // Date/Time Added: 2003-10-22 11:58:47
> // Origin:
> // Keywords: optimize,auto-optimize,backtest
> // Level: advanced
> // Flags: system,exploration,function
> // Formula URL: http://www.amibroker.com/library/formula.php?id=304
> // Details URL: http://www.amibroker.com/library/detail.php?id=304
> //
> //------------------------------------------------------------------------------
> //
> // this is a backtest framework that continously and automatically
> optimizes
> // settings for a trading rule you provide. it chooses settings that
> measure
> // best over a selectable lookback period. this re-optimization can
> be done
> // every bar, at a user-definable interval, or once at the start of
> trading.
> // it requires AFL editing to use; instructions are provided.
> //
> //------------------------------------------------------------------------------
>
> //////////////////////////////////////////////////////////////////////////
> // INTRO
> //////////////////////////////////////////////////////////////////////////
> /*
>
> ------------------------------------------------------------------------
> Auto-Optimization Framework
> v 1.0 (hah) 10/20/03 Dave Merrill (email: dmerrill at usa dot net)
> thanks to Tomasz Janeczko for AmiBroker, and everyone in the AmiBroker
> groups at Yahoo
> comments, suggestions, bug reports etc are most welcome
> ------------------------------------------------------------------------
>
>
> WHAT DOES THIS DO?
>
> you've probably done walk-forward optimizations, where you optimize a
> trading system over some time period, then trade with those settings
> for a while, optimize again at some later date, trade on, etc.. in
> fact, this is like real life, unless you assume your initial settings
> will be optimal forever and you'll never change them.
>
> this code is a backtest framework that does this continously and
> automatically. you provide a trading rule, and it constantly optimizes
> the parameters for it, always using the settings that measure best
> over a selectable lookback period. this re-optimization can be done
> every bar, at a user-definable interval, or once at the start of trading.
>
> one interesting fact is that so far, almost no trading rules I've
> tested are very profitable when managed this way, with any framework
> settings I've tried. the ones that are are far from universally
> successful over various stocks and time frames. I find this very
> interesting and quite puzzling, as is well documented on the AB group.
> maybe there are bugs that cause this; please let me know about any you
> find. maybe the equity evaluation function or other framework
> behaviors could be improved; please let me know if you come up with
> great changes. maybe it's just not a very effective method; if you can
> explain to me why this is so, please do!
>
> and lastly, if you find any hugely profitable uses for this thing, or
> other interesting insights from poking around with it, PLEASE let me
> in on 'em! (:-)
>
>
> IMPORTANT USAGE NOTE!!!!
>
> parts of this code belong to the framework itself, and shouldn't be
> modified in normal use. other parts you need to edit, to select the
> specific trading rule you want to test, and establish settings for how
> the framework will operate.
>
> all sections are clearly labelled as editable or not. it's in your
> best interest not to change the ones that say NOT EDITABLE, at least
> to start with.
>
>
> DON'T BE IMTIMIDATED
>
> though this is pretty long, it's actually not that complicated, either
> to use or in its internals. it's broken down into sections, most of
> which you don't need to even look at. if I could hide the no-touchy
> bits away I would (:-). also, a lot of it is explanation, not code,
> and a lot of the code is a collection of sample trading rules.
>
>
> INSTRUCTIONS
>
> 1) add trading rule(s) you want to test to the CUSTOM TRADING RULES
> section. see comments there for how your rules will be called, and
> what they need to do. some examples are provided. you can have as many
> rules here as you want, but only one can be in use at a time. step 3
> below controls which one is active.
>
> 2) if those rules require other custom functions, add them to the
> CUSTOM UTILITY FUNCTIONS section.
>
> 3) edit the framework function BuySellRule(), at the start of the
> FRAMEWORK CONFIGURATION section, to call the trading rule you want to
> test now.
>
> 4) edit the SetParameterRanges() call, next in the FRAMEWORK
> CONFIGURATION section, to set the ranges over which you want to test
> each of the two optimization parameters. some examples are provided;
> comment out all but the one you want to use.
>
> 5) if desired, edit the rest of the FRAMEWORK CONFIGURATION section,
> to control various aspects of how the framework itself behaves.
>
> 6) set the AA range, stock universes you want to test, and other AA
> settings, then run a Backtest or Portfolio Backtest.
>
> 7) if you want to see the parameters selected and other decisions
> being made under the hood, you can Explore instead of backtest. if
> desired, edit the EXPLORATION section at the end to change the columns
> and bars displayed; some possible extensions and modifications are
> provided. note that exploring doesn't actually trade, it's only a
> readout for your interest.
>
>
> GETTING STARTED
>
> this comes set up to run the included trading rule 'BuySellCCI'.
> backtest it on, say, the NASDAQ Composite Index, to get an idea of how
> it performs (nothing great). explore it to see the parameter values
> the framework selected (the best_p1 column). try changing the
> parameter ranges tested, as described in the instructions above.
>
> BuySellCCI uses a single parameter, requiring only 40 tests to
> optimize. this makes it quicker to run than most two-parameter
> systems, which typically need about 40 x 40 tests or more, depending
> on the number of values you want to test. performance can definitely
> be an issue as the number of tests goes up, and even single parameter
> systems can be pretty slow with a large number of stocks.
>
> in the FRAMEWORK CONFIGURATION section, try changing
> equity_lookback_bars (how far back performance is evaluated during
> optimization) and equity_lookback_frequency (how often optimization is
> done). if you want, you can actually optimize these; possible
> optimization settings are provided. be cautious in interpreting those
> results though. I'd do it more for a quick sense of how things behave
> than to necessarily choose the highest performing settings. at the
> very least, test a variety of stocks and time frames with any settings
> you arrive at, to make sure they're not a fluke.
>
> try some of the other included trading rules, maybe starting with the
> MA/EMA/DEMA/TEMA cross rules. hook them up and select parameter ranges
> to test as described in the instructions above.
>
> try adding your own trading rules, and experiment with optimization
> ranges and equity feedback parameters.
>
> try modifying the performance scoring methods, and adding your own.
>
> */
>
>
> //////////////////////////////////////////////////////////////////////////
> // FRAMEWORK INIT - NOT EDITABLE
> //////////////////////////////////////////////////////////////////////////
>
> Buy = Sell = Short = Cover = 0;
> equity_lookback_bars = equity_lookback_frequency =
> equity_lookback_smoothing = equity_drawdown_discount_pct = 0;
> e = best_e = best_perf_score = best_p1 = best_p2 = 0;
> p1_start = p2_start = 2;
> p1_end = p2_end = 20;
> p1_step = p2_step = 1;
> bar_index = BarIndex();
>
>
> //////////////////////////////////////////////////////////////////////////
> // FRAMEWORK FUNCTIONS - NOT EDITABLE
> //////////////////////////////////////////////////////////////////////////
>
> function SetParameterRanges(p1_start_p, p1_end_p, p1_step_p,
> p2_start_p, p2_end_p, p2_step_p) {
> if(p1_step_p != 0) {
> p1_start = p1_start_p;
> p1_end = p1_end_p;
> p1_step = p1_step_p;
> } else {
> p1_start = p1_end = p1_step = 1;
> }
> if(p2_step_p != 0) {
> p2_start = p2_start_p;
> p2_end = p2_end_p;
> p2_step = p2_step_p;
> } else {
> p2_start = p2_end = p2_step = 1;
> }
> }
> function PerformanceScoreMDDDiscount(e, perf_score) {
> e_max = Highest(e); // peak equity so far
> mdd = Highest(e_max - e); // max drawdown so far
> mdd_fraction = Highest(mdd / e_max); // fraction max drawdown is of
> peak equity
> perf_score = perf_score - (perf_score * mdd_fraction *
> (equity_drawdown_discount_pct/100)); // reduce score by mdd fraction
> scaled by drawdown discount
> return perf_score;
> }
>
>
> //////////////////////////////////////////////////////////////////////////
> // CUSTOM UTILITY FUNCTIONS - EDITABLE
> //////////////////////////////////////////////////////////////////////////
>
> function EMAx(array, period) { // use in place of AB EMA function when
> period needs to be an array
> return AMA(array, 1 / (period + 2));
> }
> function StochTransform(array, period) {
> return
> 100*(array-LLV(array,period))/(HHV(array,period)-LLV(array,period));
> }
> function MeanDev(array, mean, range) {
> result = 0;
> for(i = LastValue(Highest(range)); i < BarCount; i++) {
> result[i] = 0; // the mean is not 'moving' over the range (outside
> the loop)
> tm = mean[i];
> for(j = 0; j < range[i]; j++) {
> result[i] = result[i] + abs(array[i - j] - tm);
> }
> result[i] = result[i] / range[i];
> }
> return result;
> }
> function CCIx(period) { // use in place of AB CCI function when period
> needs to be an array
> // CCI = (TypicalPrice - MA(TypicalPrice, 20)) / (.015 x MeanDeviation)
> SMATP = MA(Avg, period);
> MD = MeanDev(Avg, SMATP, period);
> result = (Avg - SMATP) / (0.015 * MD);
> return result;
> }
> function TradeDivergences(array1, array2) {
> dir1 = IIf(array1 > Ref(array1, -1), 1, IIf(array1 < Ref(array1, -1),
> -1, 0));
> dir2 = IIf(array2 > Ref(array2, -1), 1, IIf(array2 < Ref(array2, -1),
> -1, 0));
> Buy = Cover = (dir1 == 1) AND (dir2 == -1);
> Sell = Short = (dir1 == -1) AND (dir2 == 1);
> }
> function TradeReversalsArith(array, threshold) {
> array = last_hi = last_lo = IIf(IsNull(array), -1, array);
> last_signal[0] = 0;
> Buy = Sell = 0;
> for(i = 1; i < BarCount; i++) {
> Buy[i] = array[i] >= last_lo[i-1] + threshold[i] AND
> last_signal[i-1] != 1 AND array[i-1] != -1;
> Sell[i] = array[i] <= last_hi[i-1] - threshold[i] AND
> last_signal[i-1] != -1 AND array[i-1] != -1;
> last_signal[i] = IIf(Buy[i], 1, IIf(Sell[i], -1, last_signal[i-1]));
> always_track = array[i-1] == -1 OR Buy[i] OR Sell[i];
> last_lo[i] = IIf(always_track OR array[i] < last_lo[i-1], array[i],
> last_lo[i-1]);
> last_hi[i] = IIf(always_track OR array[i] > last_hi[i-1], array[i],
> last_hi[i-1]);
> }
> Short = Sell;
> Cover = Buy;
> }
>
>
> /////////////////////////////////////////////////////////////////////////
> // CUSTOM TRADING RULES - EDITABLE
> /////////////////////////////////////////////////////////////////////////
>
> /*
>
> this is where you put the various trading rules you may want to test.
> only one rule can be in use at a time. select which one actually gets
> used by editing the framework function BuySellRule(), at the start of
> the FRAMEWORK CONFIGURATION section.
>
> all rules should set buy, sell, short and cover, in response to the
> parameters passed to it and whatever logic you want.
>
> your rule will be passed 3 parameters:
> dynamic (true/false) : true if parameters are arrays, not just single
> values; see ABOUT THE 'DYNAMIC' PARAMETER, below
> p1 (number/array) : first optimization parameter
> p2 (number/array) : second optimization parameter
>
> p1 and p2 are the values being optimized on. trading rules can use
> them for any optimizable purpose, MA periods or crossover thresholds
> for example.
>
> during optimization, the rule in use will be called multiple times,
> once with each combination of p1 and p2 being tested. at this time, p1
> and p2 will be simple numeric values, not arrays. once optimal
> settings have been determined for every bar, the rule will be called
> once more, to generate actual trading signals. this time, p1 and p2
> will be arrays, each bar containing the optimal p1 and p2 value for
> that bar.
>
> ABOUT THE 'DYNAMIC' PARAMETER
>
> not all AB functions can take arrays as inputs. for example, MA, TEMA
> and DEMA can use an array as their period, but EMA can't. it's usually
> possible to code an equivalent that can in AFL, but it may be slower,
> or in a DLL, which I didn't want to depend on for this. this speed
> difference can be big, since the trading rule is called many times
> during optimization.
>
> if desired, your rule can include both slower array-capable code for
> use in the final signal-generation phase, and faster,
> non-array-capable code for use during the many optimization tries. if
> you do this, use the 'dynamic' parameter to know which to call. see
> BuySellCCI, below, for an example.
>
> */
>
> function BuySellEMACrossPrice(dynamic, p1, p2) { // p1 = EMA period
> m = EMAx(C, p1);
> Buy = Cover = Cross(C, m);
> Sell = Short = Cross(m, C);
> }
> function BuySellMACross(dynamic, p1, p2) { // p1 = MA1 period, p2 =
> MA2 period increase over MA1 period
> m1 = MA(C, p1);
> m2 = MA(C, p1 + p2);
> Buy = Cover = Cross(m1, m2);
> Sell = Short = Cross(m2, m1);
> }
> function BuySellEMACross(dynamic, p1, p2) { // p1 = MA1 period, p2 =
> MA2 period increase over MA1 period
> m1 = EMAx(C, p1);
> m2 = EMAx(C, p2);
> Buy = Cover = Cross(m1, m2);
> Sell = Short = Cross(m2, m1);
> }
> function BuySellDEMACross(dynamic, p1, p2) { // p1 = MA1 period, p2 =
> MA2 period increase over MA1 period
> m1 = DEMA(C, p1);
> m2 = DEMA(C, p1 + p2);
> Buy = Cover = Cross(m1, m2);
> Sell = Short = Cross(m2, m1);
> }
> function BuySellTEMACross(dynamic, p1, p2) { // p1 = MA1 period, p2 =
> MA2 period increase over MA1 period
> m1 = TEMA(C, p1);
> m2 = TEMA(C, p1 + p2);
> Buy = Cover = Cross(m1, m2);
> Sell = Short = Cross(m2, m1);
> //short = cover = 0; // at least sometimes, short is perf_scoreable,
> but only barely, so RAR drops
> }
> function BuySellCCI(dynamic, p1, p2) { // p1 = CCI period; fixed
> threshold of zero
> if(dynamic) {
> cc = CCIx(p1);
> } else {
> cc = CCI(p1);
> }
> Buy = Cover = Cross(cc, 0);
> Sell = Short = Cross(0, cc);
> }
> function BuySellCCI2(dynamic, p1, p2) { // p1 = CCI period; moveable
> symetrical thresholds, mirrored above and below zero for long and short
> if(dynamic) {
> cc = CCIx(p1);
> } else {
> cc = CCI(p1);
> }
> Buy = Cover = Cross(cc, p2);
> Sell = Short = Cross(-p2, cc);
> }
> function BuySellCCI3(dynamic, p1, p2) { // p1 = CCI period; moveable
> absolute threshold, same numeric level for long and short
> if(dynamic) {
> cc = CCIx(p1);
> } else {
> cc = CCI(p1);
> }
> Buy = Cover = Cross(cc, p2);
> Sell = Short = Cross(p2, cc);
> }
> function BuySellStochCCI(dynamic, p1, p2) { // p1 = CCI period
> cc = CCIx(period);
> cc = StochTransform(cc, period);
> Buy = Cover = Cross(cc, 50);
> Sell = Short = Cross(50, cc);
> }
> function BuySellStoch(dynamic, p1, p2) { // p1 = range, p2 = K & D
> smoothing
> if(dynamic) {
> stoK =
> MA(100*(C-LLV(L,best_p1))/(HHV(H,best_p1)-LLV(L,best_p1)),best_p2);
> stoD = MA(stoK, best_p2);
> } else {
> stoD = StochD(p1, p2, p2);
> stoK = StochK(p1, p2);
> }
> sig = stoD - stoK;
> Buy = Cover = Cross(sig, 0);;
> Sell = Short = Cross(0, sig);
> }
> function BuySellStochDivergence(dynamic, p1, p2) { // p1 = range, p2 =
> K & D smoothing
> if(dynamic) {
> stoK =
> MA(100*(C-LLV(L,best_p1))/(HHV(H,best_p1)-LLV(L,best_p1)),best_p2);
> stoD = MA(stoK, best_p2);
> } else {
> stoD = StochD(p1, p2, p2);
> stoK = StochK(p1, p2);
> }
> TradeDivergences(stoD, stoK);
> }
> function BuySellROC(dynamic, p1, p2) { // p1 = range, p2 = threshold
> sig = ROC(MA(C, p1), 1);
> Buy = Cover = Cross(sig, p2);
> Sell = Short = Cross(p2, sig);
> }
> function BuySellDemandIndex(dynamic, p1, p2) { // p1 = DI & TEMA
> period, p2 = EMA period
> period = 21; //p1; // 21
> period2 = 30; //p2; // 30
> A=(H+L+2*C);
> B=EMAx((HHV(H,2)-LLV(L,2)),21);
> BuyP= /*{BuyPower}*/
> V/EMAx(V,21) * ((A>=Ref(A,-1)) +(A<Ref(A,-1)) / exp((0.375 *
> (A+Ref(A,-1)) /B ) *(Ref(A,-1)-A) / A));
> SellP = /*{SellPressure}*/
> V/EMAx(V,21) * ((A<=Ref(A,-1)) + (A>Ref(A,-1)) / exp((0.375 *
> (A+Ref(A,-1)) / B ) * (A-Ref(A,-1)) / Ref(A,-1)));
> mabp=EMAx(BuyP,period);
> masp=EMAx(SellP,period); // {smooth Selling Pressure}
> divsor=IIf(mabp>masp,mabp,masp); // {BP:SP ratio}
> divend=IIf(mabp<masp,mabp,masp); // {biggest=divisor}
> var2=1-(divend/divsor); // {adjust ratio to plot in}
> var3=IIf((masp>mabp), -var2, var2); // {range -100 to 100}
> var4=var3*100;
> DI = var4;
> DI_TEMA = TEMA(DI, period);
> DI_TEMA_MA = EMAx(DI_TEMA, period2);
> Buy = Cover = Cross(DI_TEMA, 0); // try various crosses of DI,
> DI_TEMA, DI_TEMA_MA and zero
> Sell = Short = Cross(0, DI_TEMA);
> Short = Cover = 0; // improves performance sometimes
> }
> function BuySellMTIReversals(dyanamic, p1, p2) { // p1 = reversal
> threshold; .12 for San Diego Wave timing
> // requires MTI in ticker !!MTI;
> // note that MTI data doesn't go back very far, and was calculated
> differently before some time in early '00
> // adjust test period and keep results in perspective accordingly
> MTI = Foreign("!!MTI", "C", True);
> TradeReversalsArith(MTI, p1);
> }
>
>
> //////////////////////////////////////////////////////////////////////////
> // PERFORMANCE SCORING METHODS - EDITABLE
> //////////////////////////////////////////////////////////////////////////
> // one of these functions will be called to evaluate the performance
> of each parameter combination tried
> // select the one that will be active by editing the framework
> function PerformanceScore
> // it's at the beginning of EQUITY FEEDBACK BEHAVIOR, in the
> FRAMEWORK CONFIGURATION section
> // you can edit these or add your own
> function PerformanceScore1() { // profit per bar
> e = Equity(0, 0);
> if(equity_lookback_bars == 0) { // test all performance to date
> e_ref = e[0];
> } else { // test performance back spec'd number of bars
> e_ref = Ref(e, -equity_lookback_bars);
> }
> perf_score = (e - e_ref) / e_ref; // growth over lookback period
> perf_score = MA(perf_score, IIf(equity_lookback_smoothing >= 1,
> equity_lookback_smoothing, 1)) * 100; // smoothed pct
> perf_score = perf_score * 100 / IIf(equity_lookback_bars == 0,
> Cum(1), equity_lookback_bars); // per 100 bars
> perf_score = PerformanceScoreMDDDiscount(e, perf_score);
> return perf_score;
> }
> function PerformanceScore2() { // net of right-sided bars per bar
> e = Equity(0, 0);
> e_ref = Ref(e, -1);
> e_delta = e - e_ref;
> last_buy_bar = ValueWhen(Buy, bar_index);
> last_sell_bar = ValueWhen(Sell, bar_index);
> last_short_bar = ValueWhen(Short, bar_index);
> last_cover_bar = ValueWhen(Cover, bar_index);
> entry_status = IIf(last_buy_bar > last_sell_bar, 1,
> IIf(last_short_bar > last_cover_bar, -1, 0));
> bar_is_right = IIf(entry_status == 1, e_delta > 0, IIf(entry_status
> == -1, e_delta < 0, 0));
> bar_is_wrong = IIf(entry_status == 1, e_delta < 0, IIf(entry_status
> == -1, e_delta < 0, 0));
> if(equity_lookback_bars == 0) { // test all performance to date
> bars_right = Cum(bar_is_right); // bars long and rising or short and
> falling
> bars_wrong = Cum(bar_is_wrong); // bars long and falling or short
> and rising
> } else { // test performance back spec'd number of bars
> bars_right = Sum(bar_is_right, equity_lookback_bars); // bars long
> and rising or short and falling
> bars_wrong = Sum(bar_is_wrong, equity_lookback_bars); // bars long
> and falling or short and rising
> }
> perf_score = (bars_right - bars_wrong) / bar_index; // net bars
> right per bar
> perf_score = MA(perf_score, IIf(equity_lookback_smoothing >= 1,
> equity_lookback_smoothing, 1)) * 100; // smoothed pct
> perf_score = PerformanceScoreMDDDiscount(e, perf_score);
> return perf_score;
> }
>
>
> //////////////////////////////////////////////////////////////////////////
> // FRAMEWORK CONFIGURATION - EDITABLE
> //////////////////////////////////////////////////////////////////////////
>
> // TRADING RULE: EDIT TO CALL THE CUSTOM RULE YOU WANT TO TEST
> function BuySellRule(dynamic, p1, p2) {
> BuySellCCI(dynamic, p1, p2);
> }
>
> // PARAMETER RANGES TO TEST
> // each of the two parameters, p1 and p2, has start, end and step
> values that control the values tried during optimization
> // you'll probably need to adjust these to the ranges that are useful
> for the active trading rule
> // to set them all at once, call SetParameterRanges(p1_start, p1_end,
> p1_step, p2_start, p2_end, p2_step)
> // if your rule doesn't use p2, use p2_step = 0 to speed up optimization
> // some typical settings are provided below; uncomment and edit the
> one you want to use
> SetParameterRanges(2, 40, 1, 1, 1, 0); // basic single parameter range
> //SetParameterRanges(2, 40, 1, 2, 40, 1); // basic two parameter ranges
> //SetParameterRanges(2, 40, 1, 0, 100, 10); // 2-40 period, 0-100
> threshold
> //SetParameterRanges(.01, .5, .01, 1, 1, 0); // for MTI reversals
>
> // EQUITY FEEDBACK BEHAVIOR
> // parameter values selected by the framework are the ones that
> performed best over a specified time in the past
> // this section controls how this is done
> // two performance metrics are provided, and you can add your own
> // only one can be active at a time
> // edit the function PerformanceScore to call the one you want to use
> // equity_lookback_bars controls how many bars worth of history will
> be examined
> // 0 = examine all performance to date
> // equity_lookback_frequency is the number of bars between optimizations
> // 0 = optimize every bar, -1 = first bar only
> // equity_lookback_smoothing applies an MA to the equity curve before
> picking optimum values
> // minimizes the effect of daily price fluctuations on optimization;
> only matters much when pretty high, multiple months
> // equity_drawdown_discount_pct reduces the performance score by the
> maximum drawdown amount * this percentage
> // at zero, MDD has no effect; at 100, 20% MDD reduces the score by 20%
> function PerformanceScore() {
> return PerformanceScore2();
> }
> equity_lookback_bars = 0; // 126 * Optimize("Equity Lookback", 0, 0,
> 5*2, 1);
> equity_lookback_frequency = 0; //21 * Optimize("Equity Lookback
> Frequency", 0, 0, 12*2, 1);
> equity_lookback_smoothing = 0; //21*6;
> equity_drawdown_discount_pct = 0; //100;
>
> // TRADE ENTRY RESTRICTIONS
> // edit to set minimum price, volume and length of history required to
> enter a trade
> // note that the volume requirement is ignored for mutual funds and
> tickers starting w '!' or '~'
> has_min_vol = (MA(V, 100) > 1000000) OR True;
> is_min_price_long = C > 1;
> is_min_price_short = C > 5;
> has_min_history = bar_index >= (252 * 3); // require 3 years of
> history before trading
>
> // PORTFOLIO MANAGEMENT
> // these settings aren't well tested (:-)
> max_positions = 0; // number of simultaneous positions to hold; zero
> for no portfolio management
> use_ranking = False; // true to rank simultaneous entry signals by
> backtest return in portfolio mode
>
>
> //////////////////////////////////////////////////////////////////////////
> //////////////////////////////////////////////////////////////////////////
> //////////////////////////////////////////////////////////////////////////
> //////////////////// FRAMEWORK ENGINE - NOT EDITABLE //////////////////
> //////////////////////////////////////////////////////////////////////////
> //////////////////////////////////////////////////////////////////////////
> //////////////////////////////////////////////////////////////////////////
>
> // tweak volume entry requirements for things with no volume data
> has_min_vol = has_min_vol
> OR (MarketID(1) == "Mutual funds") OR (StrLeft(Name(), 1) == "!") OR
> (StrLeft(Name(), 1) == "~");
>
> // loop through requested parameter ranges, calculating signals and
> choosing parameter values that score best
> first_bar_index = ValueWhen(Status("FirstBarInRange"), bar_index);
> for(p1 = p1_start; p1 <= p1_end; p1 = p1 + p1_step) {
> for(p2 = p2_start; p2 <= p2_end; p2 = p2 + p2_step) {
>
> // calc buy/sell/short/cover w those settings
> BuySellRule(False, p1, p2);
>
> // apply overall entry restrictions
> Buy = Buy AND is_min_price_long AND has_min_vol;
> Short = Short AND is_min_price_short AND has_min_vol;
>
> // calc performance score w those settings
> perf_score = PerformanceScore();
>
> // track settings w best performance and resulting equity
> if(equity_lookback_frequency == 0) {
> optimize_this_bar = 1;
> } else if(equity_lookback_frequency == -1) {
> optimize_this_bar = Status("FirstBarInRange");
> } else {
> optimize_this_bar = (first_bar_index - bar_index) %
> equity_lookback_frequency == 0;
> }
> is_new_best = IIf(optimize_this_bar AND perf_score >
> best_perf_score, 1, 0);
> best_perf_score = IIf(is_new_best, perf_score, best_perf_score);
> best_p1 = IIf(is_new_best, p1, best_p1);
> best_p2 = IIf(is_new_best, p2, best_p2);
> best_e = IIf(is_new_best, e, best_e);
> best_perf_score = IIf(optimize_this_bar, best_perf_score,
> ValueWhen(optimize_this_bar, best_perf_score));
> best_p1 = IIf(optimize_this_bar, best_p1,
> ValueWhen(optimize_this_bar, best_p1));
> best_p2 = IIf(optimize_this_bar, best_p2,
> ValueWhen(optimize_this_bar, best_p2));
> best_e = IIf(optimize_this_bar, best_e, ValueWhen(optimize_this_bar,
> best_e));
> }
> }
>
> // calc real buy/sell/short/cover w optimal settings
> BuySellRule(True, best_p1, best_p2);
>
> // apply overall entry restrictions
> Buy = Buy AND is_min_price_long AND has_min_vol AND has_min_history;
> Short = Short AND is_min_price_short AND has_min_vol AND has_min_history;
>
> // don't enter, exit now, unless lookback was perf_scoreable
> Buy = Buy AND best_perf_score > 0;
> Short = Short AND best_perf_score > 0;
> Sell = Sell OR best_perf_score <= 0;
> Cover = Cover OR best_perf_score <= 0;
>
> // kill sells and covers before respective entries; cleans up exploration
> Sell = Sell AND Cum(Buy);
> Cover = Cover AND Cum(Short);
>
> // kill dupe signals, for exploration
> Sell = ExRem(Sell, Buy);
> Cover = ExRem(Cover, Short);
>
> // set PostionSize and PositionScore if requested
> if(max_positions > 0) {
> PositionSize = -((100 / max_positions) - 1);
> }
> if(use_ranking) {
> PositionScore = IIf(Buy, best_perf_score, IIf(Short,
> -best_perf_score, 0));
> }
>
>
> //////////////////////////////////////////////////////////////////////////
> // EXPLORATION - EDITABLE IF YOU WANT, BUT USUALLY NOT NECCESSARY
> //////////////////////////////////////////////////////////////////////////
>
> Filter = Buy OR Sell OR Short OR Cover;
> //filter = optimize_this_bar; // to show every bar where optimization
> was done
> //filter = filter or Ref(filter, 1); // to show the day before each
> signal too
> //filter = 1; //to show all bars
>
> AddColumn(bar_index, "Bar Index", 1.0);
> AddColumn(Buy, "buy", 1);
> AddColumn(Sell, "sell", 1);
> AddColumn(Short, "short", 1);
> AddColumn(Cover, "cover", 1);
> AddColumn(optimize_this_bar, "optimize_this_bar", 1.0);
> AddColumn(best_perf_score, "best_perf_score", 1.4);
> AddColumn(best_e, "best_e", 1.0);
> AddColumn(((ValueWhen(Filter OR Status("LastBarInTest"), best_e, 0) -
> best_e) / best_e) * 100, "best_e_pct_change", 1.2);
> AddColumn(best_p1, "best_p1");
> AddColumn(best_p2, "best_p2");
> AddColumn(BarsSince(best_p1 != Ref(best_p1, -1) OR best_p2 !=
> Ref(best_p2, -1)) + 1, "bars_since_settings", 1.0);
> AddColumn(ValueWhen(Filter OR Status("LastBarInTest"), bar_index, 0) -
> bar_index, "bars", 1.0);
> AddColumn(has_min_history, "has_min_vol", 1.0);
> AddColumn(has_min_history, "has_min_history", 1.0);
> AddColumn(C, "price");
> AddColumn(equity_lookback_bars, "equity_lookback_bars");
> AddColumn(equity_lookback_frequency, "equity_lookback_frequency");
>
> // enable next lines to see more optimization details; note that only
> the last parameter set tried will show
> //AddColumn(e, "e");
> //AddColumn(e_ref, "e_ref");
> //AddColumn(perf_score, "perf_score", 1.4);
>
> // TRADING THE MACD Ver 1.0 by Karthik Marar. AFL provided as a part
> of the Discussion on trading the MACD in the Thread " Experiments in
> Technical Analysis"
> // Afl provided to learn and get an insight for trading using the
> MACD. The AFL can be freely distributed except for commercial purpose.
>
> _SECTION_BEGIN("MACD optimize");
> //------------------------------------------------------------------------------
> //
> // Formula Name: MACD optimize
> // Author/Uploader: Grayesso
> // E-mail: grayesso@xxx
> // Date/Time Added: 2003-12-10 14:12:39
> // Origin:
> // Keywords:
> // Level: advanced
> // Flags: showemail,function
> // Formula URL: http://www.amibroker.com/library/formula.php?id=313
> // Details URL: http://www.amibroker.com/library/detail.php?id=313
> //
> //------------------------------------------------------------------------------
> //
> // MACD (12,26,9 - 5,34,5 <==> by default - by Bill Williams
> //
> //------------------------------------------------------------------------------
>
> /* Project: AmiBroker
> ** File: MACD_optimize.afl
> ** Title: MACD Optimize for Automatic Analysis (English)
> ** Date: Dec 10th, 2003
> ** Written by: Grayesso (grayesso dog rambler dot ru)
> */
>
> /*After entering the formula just click on Optimize button in
> "Automatic Analysis" window. AmiBroker will start testing all possible
> combinations of optimization variables and report the results in the
> list. After optimization is done the list of result is presented
> sorted by the Net % profit. As you can sort the results by any column
> in the result list it is easy to get the optimal values of parameters
> for the lowest drawdown, lowest number of trades, largest profit
> factor, lowest market exposure and highest risk adjusted annual %
> return. The last three columns of result list present the values of
> optimization variables for given test.
>
>
> When you decide which combination of parameters suits your needs the
> best all you need to do is to replace the default values in optimize
> function calls with the optimal values. At current stage you need to
> type them by hand in the formula edit window (the second parameter of
> optimize function call). */
>
> /* MACD (12,26,9 - 5,34,5 <==> by default - by Bill Williams */
>
> /* variable = optimize( "Description", default, min, max, step ) */
>
>
> fa = Optimize( "MACD Fast", 5, 5, 12, 1 );
> sa = Optimize("MACD Slow", 34, 26, 34, 1 );
> sig = Optimize( "Signal average", 5, 5, 9, 1 );
>
> Buy = Cross( MACD( fa, sa ) , Signal( fa, sa, sig ) );
> Sell = Cross( Signal( fa, sa, sig ), MACD( fa, sa ) );
> _SECTION_END();
>
>
> _SECTION_BEGIN("Randomize");
> //------------------------------------------------------------------------------
> //
> // Formula Name: Randomize()
> // Author/Uploader: Antonio Marra
> // E-mail: ant.marra@xxx
> // Date/Time Added: 2004-07-20 06:40:47
> // Origin:
> // Keywords: Random interval
> // Level: basic
> // Flags: showemail,function
> // Formula URL: http://www.amibroker.com/library/formula.php?id=365
> // Details URL: http://www.amibroker.com/library/detail.php?id=365
> //
> //------------------------------------------------------------------------------
> //
> // This function will generate random numbers included in a given numeric
> // interval.
> //
> //------------------------------------------------------------------------------
>
> /*_________________________________________________________________________________________
>
>
> SYNTAX:
> Randomize(a,b)
>
> PURPOSE:
> This function will generate random numbers included in a
> given numeric interval.
>
> HOW TO USE:
> Copy this file in your include directory or append it to
> another file that You
> use as "functions database".
> "a" is the lowest value, "b" is the highest value.
>
> EXAMPLE:
> 1. if you want to generate random between 1 e 100 (with
> decimal values):
>
> RandomNumber = Randomize(1,100);
>
> 2. if you want to generate random between 1 e 100 (with only
> integer values):
>
> RandomNumber = int( Randomize(1,100) ) ;
>
>
> ________________________________________________________________________________________
>
>
> */
>
>
> function Randomize(a,b)
> {
> result = Random()*(b-a)+a;
> return result;
> }
> _SECTION_END();
>
> _SECTION_BEGIN("sort function");
> //------------------------------------------------------------------------------
> //
> // Formula Name: sort function
> // Author/Uploader: walt schwarz
> // E-mail: wschwarz@xxx
> // Date/Time Added: 2003-05-26 17:11:16
> // Origin:
> // Keywords: sort array function
> // Level: medium
> // Flags: showemail,function
> // Formula URL: http://www.amibroker.com/library/formula.php?id=283
> // Details URL: http://www.amibroker.com/library/detail.php?id=283
> //
> //------------------------------------------------------------------------------
> //
> // will return the passed array in sorted order
> //
> //------------------------------------------------------------------------------
>
> function sort(inlist)
>
> {
>
> //sort inlist
>
> temp=0;
>
> for(i = BarCount-1; i>=0; i--)
>
> {
>
> for (j = 1; j <= i; j++)
>
> {
>
> if (inlist[j-1] > inlist[j])
>
> {
>
> temp = inlist[j-1];
>
> inlist[j-1] = inlist[j];
>
> inlist[j] = temp;
>
> }
>
> }
>
> }
>
> //inlist now sorted
>
> return inlist;
>
> }
>
> _SECTION_END();
>
> SetCustomBacktestProc("");
> if( Status("action") == actionPortfolio )
> {
> bo = GetBacktesterObject();
> bo.Backtest();
> Buy = 0;
> Sell= 0;
> PosTradePos = 0;
> NegTradePos = 0;
> }
>
> _SECTION_BEGIN("EOD v1.1 Mod");
> #include <T3_include.AFL>;
> //WAD
> TrueRangeHigh=Max( Ref(Close,-1), High );
> TrueRangeLow=Min( Ref(Close,-1), Low );
> WAD = Cum(IIf(C > Ref(C,-1),C-TrueRangeLow, IIf(C <
> Ref(C,-1),C-TrueRangeHigh,0)));
> wadup = WAD > EMA (WAD,20);
> waddn = WAD < EMA (WAd,20);
> wadbl = Cross(WAD, EMA(WAD,20));
> wadbr = Cross(EMA(WAD,20), WAD);
> wad_status= WriteIf(wadup, "Bullish Zone", WriteIf(waddn, "Bearish
> Zone", WriteIf(wadbl, "Bullish Cross", WriteIf(wadbr, "Bearish Cross",
> "Zilch"))));
> wad_Col=IIf(wadup OR wadbl, colorGreen, IIf(waddn OR wadbr, colorRed,
> colorLightGrey));
>
>
> //Trend Strength
> up = ADX(10) > 20;
> down = ADX(10) < 20;
> choppy = ADX(10) < PDI(10) AND ADX(10) < MDI(10);
> adx_status= WriteIf(up, "Strong Trend", WriteIf(down, "Weak Trend",
> WriteIf( choppy, "Choppy", "Zilch")));
> adx_Col=IIf(up, colorGreen, IIf(down, colorRed, IIf(Choppy, colorPink,
> colorLightGrey)));
>
> // Coppock
> r1=ROC(C,14);
> r2=ROC(C,11);
> ck=EMA((r1+r2),10);
> upt=IIf(ck>0 AND ROC(ck,1)>0,ck,0);
> ups=IIf(ck>0 AND ROC(ck,1)<0,ck,0);
> downs=IIf(ck<0 AND ROC(ck,1)>0,ck,0);
> down=IIf(ck<0 AND ROC(ck,1)<0,ck,0);
> cop_status= WriteIf(upt, "Uptrend", WriteIf(ups, "Uptrend Sidways",
> WriteIf(downs, "Downtrend Sideways", WriteIf(down, "Downtrend",
> "Zilch"))));
> cop_Col=IIf(upt, colorDarkGreen, IIf(ups, colorGreen, IIf(downs,
> colorOrange, IIf(down, colorRed, colorLightGrey))));
>
> //Initial Buy Signal
> Ibuy = Cross(RSI(14), EMA(RSI(14),9));
> Isell = Cross(EMA(RSI(14),9), RSI(14));
> Ibuy = ExRem(Ibuy, ISell);
> Isell = ExRem(ISell, Ibuy);
> BlRSI = RSI(14) > EMA(RSI(14),9);
> BrRSI = RSI(14) < EMA(RSI(14),9);
> Ibuy_status= WriteIf(Ibuy, "Buy Warning", WriteIf(Isell, "Sell
> Warning", WriteIf(BlRSI, "Bullish Zone", WriteIf(BrRSI, "Breaish
> Zone", "Zilch"))));
> I_Col=IIf(Ibuy OR BlRSI, colorGreen, IIf(Isell OR BrRSI, colorRed,
> colorLightGrey));
>
> //BB Breakout
> bbk2 = Cross(RSI(14),30) AND
> RSI(14) > Ref(RSI(14),-1);
> bbk_status= WriteIf(bbk2, "Break RSI", "Zilch" );
> bbk_Col=IIf(bbk2, colorGreen, colorLightGrey);
>
>
> //Price Smoothing
> TBuy = Cross (T3(C,3), T3(C,5));
> TSell = Cross (T3(C,5), T3(C,3));
> TBuy = ExRem(TBuy, TSell);
> TSell = ExRem(TSell, TBuy);
> Tbuy_status= WriteIf(TBuy, "Buy", WriteIf(TSell, "Sell", "Zilch"));
> T_Col=IIf(TBuy, colorGreen, IIf(TSell, colorRed, colorLightGrey));
>
> //Guppy MMA
> P1 = EMA(C,3);
> P2 = EMA(C,5);
> P3 = EMA(C,8);
> P4 = EMA(C,10);
> P5 = EMA(C,12);
> P6 = EMA(C,15);
> P7 = EMA(C,30);
> P8 = EMA(C,35);
> P9 = EMA(C,40);
> P10 = EMA(C,45);
> P11 = EMA(C,50);
> P12 = EMA(C,55);
> P13 = EMA(C,60);
> GBuy = Cross (P1,P8);
> GSell = Cross(P8,P1);
> GBuy = ExRem(GBuy, GSell);
> GSell = ExRem(GSell, GBuy);
> Gbuy_status= WriteIf(GBuy, "Buy", WriteIf(GSell, "Sell", "Zilch"));
> G_Col=IIf(GBuy, colorGreen, IIf(GSell, colorRed, colorLightGrey));
>
> //EMA-9
> MAbuy = Cross(C, EMA(C,9));
> MAsell= Cross(EMA(C,9),C);
> MAbuy = ExRem(MAbuy, MAsell);
> MAsell = ExRem(MAsell, MAbuy);
> MA1 = C > EMA(C,9);
> MA11 = C < EMA(C,9);
> MA_status= WriteIf(MAbuy, "Buy", WriteIf(MAsell, "Sell", WriteIf(MA1,
> "Bullish", WriteIf(MA11, "Bearish","Zilch"))));
> MA_Col=IIf(MAbuy OR MA1, colorGreen, IIf(MAsell OR MA11, colorRed,
> colorLightGrey));
>
> //EMA-20
> MA2buy = Cross(C, EMA(C,20));
> MA2sell= Cross(EMA(C,20),C);
> MA2buy = ExRem(MA2buy, MA2sell);
> MA2sell = ExRem(MA2sell, MA2buy);
> MA2 = C > EMA(C,20);
> MA22 = C < EMA(C,20);
> MA2_status= WriteIf(MA2buy, "Buy", WriteIf(MA2sell, "Sell",
> WriteIf(MA2, "Bullish", WriteIf(MA22, "Bearish","Zilch"))));
> MA2_Col=IIf(MA2buy OR MA2, colorGreen, IIf(MA2sell OR MA22, colorRed,
> colorLightGrey));
>
> //EMA-9 x 20
> MA3buy = Cross(EMA(C,9), EMA(C,20));
> MA3sell= Cross(EMA(C,20),EMA(C,9));
> MA3buy = ExRem(MA3buy, MA3sell);
> MA3sell = ExRem(MA3sell, MA3buy);
> MA3 = EMA(C,9) > EMA(C,20);
> MA33 = EMA(C,9) < EMA(C,20);
> MA3_status= WriteIf(MA3buy, "Buy", WriteIf(MA3sell, "Sell",
> WriteIf(MA3, "Bullish", WriteIf(MA33, "Bearish","Zilch"))));
> MA3_Col=IIf(MA3buy OR MA3, colorGreen, IIf(MA3sell OR MA33, colorRed,
> colorLightGrey));
>
> //Midterm Bullish or Bearish
> mBull = C > EMA(C,50);
> mBear= C < EMA(C,50);
> mt_status= WriteIf(mBull, "Bullish", WriteIf(mBear, "Bearish", "Zilch"));
> mt_Col=IIf(mBull, colorGreen, IIf(mbear, colorRed, colorLightGrey));
>
> //Longterm Bullish or Bearish
> Bull = C > EMA(C,200);
> Bear= C < EMA(C,200);
> lt_status= WriteIf(Bull, "Bullish", WriteIf(Bear, "Bearish", "Zilch"));
> lt_Col=IIf(Bull, colorGreen, IIf(bear, colorRed, colorLightGrey));
>
> //Long-term Price Trend
> rc= C > EMA (C,50) AND C < EMA(C,200) AND EMA(C,50) < EMA(C,200);
> ac= C > EMA (C,50) AND C > EMA(C,200) AND EMA(C,50) < EMA(C,200);
> bl= C > EMA (C,50) AND C > EMA(C,200) AND EMA(C,50) > EMA(C,200);
> wr= C < EMA (C,50) AND C > EMA(C,200) AND EMA(C,50) > EMA(C,200);
> ds= C < EMA (C,50) AND C < EMA(C,200) AND EMA(C,50) > EMA(C,200);
> br= C < EMA (C,50) AND C < EMA(C,200) AND EMA(C,50) < EMA(C,200);
>
> ltp=WriteIf(rc, "RECOVERY", WriteIf(ac, "ACCUMULATION", WriteIf(bl,
> "BULLISH", WriteIf(wr, "WARNING",WriteIf(ds,
> "DISTRIBUTION",WriteIf(br, "BEARISH", "Zilch"))))));
> ltp_col=IIf( rc, colorBlue, IIf( ac, colorGreen, IIf(bl,
> colorDarkGreen, IIf(wr, colorOrange, IIf(ds, colorRed, IIf(br,
> colorDarkRed, colorLightGrey ))))));
>
> G=((O-Ref(L,-1))/Ref(L,-1))*100;
> F=((C-Ref(C,-1))/Ref(C,-1))*100;
>
> //T-3 Delta
> T3Day = T3(Close, 3);
> T5Day = T3(Close, 5);
> Delta = T3Day - T5Day;
>
>
> Filter=O<Ref(L,-1) AND C>Ref(C,-1)|C>Ref(O,-1)
> AND L<Ref(L,-1) AND Ref(L,-1)<Ref(L,-2) AND Ref(L,-2)<Ref(L,-3)
> AND V>Ref(V,-1) AND V>(MA(Ref(V,-1),5)+(MA(Ref(V,-1),5)*0.3)) AND
> MA(V,21)>50000;
>
> Buy=Filter;
>
> AddColumn(V, "Volome", 1, IIf(V > Ref(V,-1), colorGreen, colorRed),-1);
> AddColumn(((V/EMA(Ref(V,-1),10)))*100, "VolSpike %", 1.2, IIf(V>
> EMA(Ref(V,-1),10), colorBlue, colorRed),-1);
> AddColumn(Delta, "Delta",1.2, IIf(delta < 0, colorRed, colorGreen),-1);
> AddColumn(C, "Close", 1.2, IIf(C > Ref(C,-1), colorGreen, colorRed),-1);
> AddColumn(G,"O Low%",1.2,-1);
> AddColumn(F,"C High%",1.2,-1);
> AddColumn(RSI(14),"RSI-14",1.2, IIf(RSI(14) > Ref(RSI(14),-1),
> colorGreen, colorRed),-1);
> AddColumn(ADX(10),"ADX-10",1.2,IIf(ADX(10) > Ref(ADX(10),-1),
> colorGreen, colorRed),-1);
> AddTextColumn(bbk_status, "Breaks", 1.6, colorWhite, bbk_Col,-1);
> AddTextColumn(Tbuy_status, "T3-Signal", 1.6, colorWhite, T_Col,-1);
> AddTextColumn(Gbuy_status, "Guppy", 1.6, colorWhite, G_Col,-1);
> AddTextColumn(MA_status, "EMA-9", 1.6, colorWhite, MA_Col,-1);
> AddTextColumn(MA2_status, "EMA-20", 1.6, colorWhite, MA2_Col,-1);
> AddTextColumn(MA3_status, "EMA-9x20", 1.6, colorWhite, MA3_Col,-1);
> AddTextColumn(Ibuy_status, "RSI signal", 1.6, colorWhite, I_Col,-1);
> AddTextColumn(adx_status, "Trend", 1.6, colorWhite, adx_Col,-1);
> AddTextColumn(cop_status, "Coppock", 1.6, colorWhite, cop_Col,-1);
> AddTextColumn(mt_status, "Mid Term", 1, colorWhite, mt_Col);
> AddTextColumn(lt_status, "Long Term", 1, colorWhite, lt_Col);
> //AddTextColumn(wad_status, "WAD", 1.6, colorWhite, WAD_Col,-1);
> //AddTextColumn(mt_status, "EMA-50", 1.6, colorWhite, mt_Col,-1);
> //AddTextColumn(lt_status, "EMA-200", 1.6, colorWhite, lt_Col,-1);
> AddTextColumn(ltp, "Phase", 1.6, colorWhite, ltp_Col,-1);
>
>
> _SECTION_END();
>
> _SECTION_BEGIN("All in One EOD Explorer");
> //52 Week New High-New Low
> HI = High > Ref(HHV(High,260),-1);
> LI = Low < Ref(LLV(Low,260),-1);
> W_status= WriteIf(HI, "High", WriteIf(LI, "Low", "Neutral"));
> W_Col=IIf(HI, colorGreen, IIf(LI, colorRed, colorLightGrey));
>
>
> //Price Volume Breakout
> HIV = C > Ref (C,-1) AND V > (MA(V,50)*2);
> LIV = C < Ref (C,-1) AND V < (MA(V,50)*2);
> V_status= WriteIf(HIV, "Gainer", WriteIf(LIV, "Loser", "Neutral"));
> V_Col=IIf(HIV, colorGreen, IIf(LIV, colorRed, colorLightGrey));
>
>
> //50/200 Crosses
> BC= Cross(MA(C,50),MA(C,200));
> BR= Cross(MA(C,200),MA(C,50));
> B_status= WriteIf(BC, "Bullish", WriteIf(BR, "Bearish", "Neutral"));
> B_Col=IIf(BC, colorGreen, IIf(BR, colorRed, colorLightGrey));
>
> //MACD Crosses
> MB= Cross (MACD(), Signal());
> MS = Cross( Signal(), MACD());
> MB_status= WriteIf(MB, "Bullish", WriteIf(MS, "Bearish", "Neutral"));
> MS_Col=IIf(MB, colorGreen, IIf(MS, colorRed, colorLightGrey));
>
> //RSI Status
> r=RSI(14) < 70 AND Ref (RSI(14),-1) > 70 AND Ref (RSI(14),-2) > 70;
> r2= RSI(14) > 70 AND Ref (RSI(14),-1) < 70 AND Ref (RSI(14),-2) < 70;
> r_status= WriteIf(r, "Declining", WriteIf(r2, "Improving", "Neutral"));
> r_Col=IIf(r, colorGreen, IIf(r2, colorRed, colorLightGrey));
>
> //Bollinger Bands
> bb= C > BBandTop( C, 20, 2) AND Ref (C,-1) < Ref(BBandTop( C, 20, 2),-1);
> bb1= C < BBandBot( C, 20, 2) AND Ref (C,-1) > Ref(BBandBot( C, 20, 2),-1);
> bb_status= WriteIf(BB, "AboveTop", WriteIf(r2, "BelowBottom", "Neutral"));
> bb_Col=IIf(r, colorGreen, IIf(r2, colorRed, colorLightGrey));
>
> //Daily Acc/Dist Status
> acc = AccDist() > Ref (AccDist(),-1);
> dist = AccDist() < Ref (AccDist(),-1);
> ad_status= WriteIf(acc, "Accumulation", WriteIf(dist, "Distribution",
> "Neutral"));
> ad_Col=IIf(acc, colorGreen, IIf(dist, colorRed, colorLightGrey));
>
> //Midterm Bullish or Bearish
> mBull = C > EMA(C,50);
> mBear= C < EMA(C,50);
> mt_status= WriteIf(mBull, "Bullish", WriteIf(mBear, "Bearish", "Zilch"));
> mt_Col=IIf(mBull, colorGreen, IIf(mbear, colorRed, colorLightGrey));
>
> //Longterm Bullish or Bearish
> Bull = C > MA(C,200);
> Bear= C < MA(C,200);
> lt_status= WriteIf(Bull, "Bullish", WriteIf(Bear, "Bearish", "Neutral"));
> lt_Col=IIf(Bull, colorGreen, IIf(bear, colorRed, colorLightGrey));
>
> //Median Price
> mp=(H+L)/2;
>
> Filter = HI OR LI OR HIV OR LIV OR BC OR BR OR MB OR MS OR acc OR dist
> OR bull OR bear;
>
> AddColumn(C, "Close", 1.2, IIf(C > Ref(C,-1), colorGreen, colorRed));
> AddColumn(ROC(C,1), "ROC Price", 1.2, IIf(ROC(C,1) > 0, colorGreen,
> colorRed));
> AddColumn(mp, "Median Price", 1.2, IIf(mp > Ref(mp,-1), colorGreen,
> colorRed));
> AddColumn(V, "Volume", 1, IIf(V > Ref(V,-1), colorGreen, colorRed));
> AddColumn(ROC(V,1), "ROC Volume", 1.2, IIf(ROC(V,1) > 0, colorGreen,
> colorRed));
> AddTextColumn(V_status, "Price Volume Breakout", 1, colorWhite, V_Col);
> AddTextColumn(ad_status, "Acc/Dist", 1, colorWhite, ad_Col);
> AddColumn(NVI(), "NVI", 1, IIf(NVI() > Ref(NVI(),-1), colorGreen,
> colorRed));
> AddColumn(MFI(21),"MFI-21",1.2, IIf(MFI(21) > Ref(MFI(21),-1),
> colorGreen, colorRed));
> AddColumn(RSI(14),"RSI-14",1.2, IIf(RSI(14) > Ref(RSI(14),-1),
> colorGreen, colorRed));
> AddColumn(ADX(14),"ADX-14",1.2,IIf(ADX(14) > Ref(ADX(14),-1),
> colorGreen, colorRed));
> AddTextColumn(bb_status, "BBand", 1, colorWhite, bb_Col);
> AddTextColumn(MB_status, "MACDX", 1, colorWhite, MS_Col);
> AddTextColumn(W_status, "52-Week", 1, colorWhite, W_Col);
> AddTextColumn(B_status, "50/200", 1, colorWhite, B_Col);
> AddTextColumn(mt_status, "Mid Term", 1, colorWhite, mt_Col);
> AddTextColumn(lt_status, "Long Term", 1, colorWhite, lt_Col);
> _SECTION_END();
>
> Buy = Cover =Cross( MACD(), 0 );
> Sell = Short =Cross( 0, MACD() );
>
> Filter = Cross( MACD(), 0 );
>
> Buy = ExRem(Buy,Sell);
> Sell = ExRem(Sell,Buy);
>
> a=EMA(C,30)-EMA(C,200);
> b=EMA(a,20);
>
>
> Buy = Cross( a,b );
> Sell = Cross( b,a );
> //Short = Sell;
> //Cover = Buy;
>
> AlertIf( Buy, "", "MACD BUY", 1,1+2 );
>
> AlertIf( Sell, "", "MACD SELL", 2 ,1+2);
>
> --- End forwarded message ---
>
>
>
> ------------------------------------
>
> Please note that this group is for discussion between users only.
>
> To get support from AmiBroker please send an e-mail directly to
> SUPPORT {at} amibroker.com
>
> For NEW RELEASE ANNOUNCEMENTS and other news always check DEVLOG:
> http://www.amibroker.com/devlog/
>
> For other support material please check also:
> http://www.amibroker.com/support.html
> Yahoo! Groups Links
>
>
>
>
> ------------------------------------------------------------------------
>
>
> No virus found in this incoming message.
> Checked by AVG - http://www.avg.com
> Version: 8.0.169 / Virus Database: 270.6.15/1648 - Release Date: 9/2/2008 5:29 PM
>
------------------------------------
Please note that this group is for discussion between users only.
To get support from AmiBroker please send an e-mail directly to
SUPPORT {at} amibroker.com
For NEW RELEASE ANNOUNCEMENTS and other news always check DEVLOG:
http://www.amibroker.com/devlog/
For other support material please check also:
http://www.amibroker.com/support.html
Yahoo! Groups Links
<*> To visit your group on the web, go to:
http://groups.yahoo.com/group/amibroker/
<*> Your email settings:
Individual Email | Traditional
<*> To change settings online go to:
http://groups.yahoo.com/group/amibroker/join
(Yahoo! ID required)
<*> To change settings via email:
mailto:amibroker-digest@xxxxxxxxxxxxxxx
mailto:amibroker-fullfeatured@xxxxxxxxxxxxxxx
<*> To unsubscribe from this group, send an email to:
amibroker-unsubscribe@xxxxxxxxxxxxxxx
<*> Your use of Yahoo! Groups is subject to:
http://docs.yahoo.com/info/terms/
|