|
PureBytes Links
Trading Reference Links
|
sir,
actually i want to make this in simpler way can u help me to cut some or make it simplier cause i am mix various fromula. i gots results but i want a profitable eod system that gives me buy & sell signals with buy price & sell price also stop loss but its profitable results. for daytrading as well as in short mid & long term.
thanks
regards
vinod
On Wed, 03 Sep 2008 Grant Noble wrote :
>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
> >
regards,
vinod
shree balaji enterprises
9860287788
![Ebay]() |
__._,_.___
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
![]()
__,_._,___
|