开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
Gordon Rose.afl
资源名称：AFL_collection.rar　[点击查看]
上传用户：shiqiang
上传日期：2009-06-12
资源大小：1289k
文件大小：30k
源码类别：

金融证券系统

开发平台：

Others

Gordon Rose.afl：源码内容
  1. //------------------------------------------------------------------------------
  2. //
  3. //  Formula Name:    Gordon Rose
  4. //  Author/Uploader: Gordon Rose 
  5. //  E-mail:          
  6. //  Date/Time Added: 2004-02-05 00:05:21
  7. //  Origin:          Strong desire to use pivots and patterns as basis for trading setups and trading.
  8. //  Keywords:        pivot fibonacci tcz
  9. //  Level:           semi-advanced
  10. //  Flags:           system,exploration,indicator
  11. //  Formula URL:     http://www.amibroker.com/library/formula.php?id=326
  12. //  Details URL:     http://www.amibroker.com/library/detail.php?id=326
  13. //
  14. //------------------------------------------------------------------------------
  15. //
  16. //  Both indicator and exploration code for combination of fibonacci
  17. //  retracements identified in "Fibonacci for the Active Trader" by Derrik
  18. //  Hobbes. Determines pivots, draws retracements, and explores for them.
  19. //
  20. //------------------------------------------------------------------------------
  22. // **************************
  23. // BEING EXPLORATION CODE
  24. // **************************
  26. // -- what will be our lookback range for the hh and ll?
  27. nBars = Param("Number of bars", 12, 5, 40);
  28. bTrace = Param("Include trace output", 1, 0, 1);
  29. nNoPivsInSetup = Param("No. Pivs in Setup", 4, 3, 4, 1);
  30. bShowTCZ = Param("Show TCZ", 1, 0, 1); 
  31. nMinBarsBtwPivs = Param("Min. number of bars btw. pivots", 1, 1, 10, 1);
  32. nMinPctBtwPivs = Param("Min. percent diff. btw. pivots", .05, .04, .2, .01);
  33. bLastBarCanBePiv = Param("Last bar can be a pivot", 1, 0, 1); 
  34. retrcTolerance = .01;
  35. tczTolerance = .005;
  36. nNumBarsToScan = 120;
  38. // -- added from exploration version 20040204
  39. nExploreBarIdx = 0;
  40. nExploreDate = 0;
  41. nCurDateNum = 0;
  42. DN = DateNum();
  43. DT = DateTime();
  45. // -- key exploration variables
  46. bTCZLong = False;
  47. bTCZShort = False;
  48. nAnchorPivIdx = 0;
  50. ADX8 = ADX(8);
  52. // 1 - INDICATOR, 2 - COMMENTARY, 3 - SCAN, 
  53. // 4 - EXPLORATION, 5 - BACKTEST / Optimize 
  54. if(Status("action")==1) {
  55. bDraw = True;
  56. bUseLastVis = Param("Use last visible bar", 1, 0, 1);
  57. } else {
  58. bDraw = False;
  59. bUseLastVis = False;
  60. bTrace = False;
  61. nExploreDate = Status("rangetodate");
  62. for (i=LastValue(BarIndex());i>=0;i--) {
  63. nCurDateNum = DN[i];
  64. if (nCurDateNum == nExploreDate) {
  65. nExploreBarIdx = i;
  66. }
  67. }
  68. // -- if(Status("action")==1...
  69. }
  71. GraphXSpace=7;
  73. // -- basic candle chart
  74. // -- if this appears inside if block, strange
  75. //    drawing results!
  76. PlotOHLC(Open, High, Low, Close, 
  77. "BIdx = " + BarIndex() + 
  78. "n" + "O = " + O + "n"+"H = "+ H + "n"+"L  = " + L 
  79. + "n"+"C ",
  80. colorBlack, styleCandle); 
  82. if (bDraw) {
  83. Plot(MA(C, 21), "21 bar MA", colorAqua, 
  84. styleLine+styleNoRescale+styleNoLabel);
  85. Plot(MA(C, 55), "55 bar MA", colorGreen, 
  86. styleLine+styleNoRescale+styleNoLabel);
  87. //Plot(MA(C, 233), "233 bar MA", colorDarkRed, 
  88. // styleLine+styleNoRescale+styleNoLabel);
  89. }
  91. // -- Create 0-initialized arrays the size of barcount
  92. aHPivs = H - H;
  93. aLPivs = L - L;
  94. aHPivHighs = H - H;
  95. aLPivLows = L - L;
  96. aHPivIdxs = H - H;
  97. aLPivIdxs = L - L;
  98. aAddedHPivs = H - H;
  99. aAddedLPivs = L - L;
  100. aLegVol = H - H;
  101. aRetrcVol = H - H;
  103. nHPivs = 0;
  104. nLPivs = 0;
  106. lastHPIdx = 0;
  107. lastLPIdx = 0;
  108. lastHPH = 0;
  109. lastLPL = 0;
  110. curPivBarIdx = 0;
  112. // -- looking back from the current bar, how many bars 
  113. //    back were the hhv and llv values of the previous 
  114. //    n bars, etc.?
  115. aHHVBars = HHVBars(H, nBars);
  116. aLLVBars = LLVBars(L, nBars);
  117. aHHV = HHV(H, nBars);
  118. aLLV = LLV(L, nBars);
  120. // -- Initialize value of curTrend
  121. nLastVisBar = LastValue(
  122. Highest(IIf(Status("barvisible"), BarIndex(), 0)));
  124. curBar = IIf(nlastVisBar > 0 AND bUseLastVis, nlastVisBar, 
  125. IIf(Status("action")==4 AND nExploreBarIdx > 0, nExploreBarIdx,
  126. LastValue(BarIndex())));
  128. curTrend = "";
  129. if (aLLVBars[curBar] < aHHVBars[curBar]) 
  130. curTrend = "D";
  131. else 
  132. curTrend = "U";
  134. // -- Loop through bars. Search for 
  135. //    entirely array-based approach
  136. //    in future version
  137. /* *******************
  138. Find main pivots
  139. ******************* */
  141. // -- Make sure there are enough bars!
  142. if (curBar >= nNumBarsToScan) {
  143. for (i=0; i<nNumBarsToScan; i++) {
  145. // -- value of curBar dependent on two parameters
  146. curBar = IIf(nlastVisBar > 0 AND bUseLastVis, 
  147. nlastVisBar-i, 
  148. IIf(Status("action")==4 AND nExploreBarIdx > 0, 
  149. nExploreBarIdx-i,
  150. LastValue(BarIndex())-i));
  152. // -- Have we identified a pivot? If trend is down...
  153. if (aLLVBars[curBar] < aHHVBars[curBar]) {
  155. // ... and had been up, this is a trend change
  156. if (curTrend == "U") {
  157. curTrend = "D";
  158. // -- Capture pivot information
  159. curPivBarIdx = curBar - aLLVBars[curBar];
  160. aLPivs[curPivBarIdx] = 1;
  161. aLPivLows[nLPivs] = L[curPivBarIdx];
  162. aLPivIdxs[nLPivs] = curPivBarIdx;
  163. nLPivs++;
  164. }
  165. // -- or current trend is up
  166. } else {
  167. if (curTrend == "D") {
  168. curTrend = "U";
  169. curPivBarIdx = curBar - aHHVBars[curBar];
  170. aHPivs[curPivBarIdx] = 1;
  171. aHPivHighs[nHPivs] = H[curPivBarIdx];
  172. aHPivIdxs[nHPivs] = curPivBarIdx;
  173. nHPivs++;
  174. }
  175. // --  If curTrend is up...else...
  176. }
  178. // -- loop through bars
  179. } 
  180. }
  181. /* *******************
  182. Found main pivots
  183. ******************* */
  185. /* *************************
  186. Finding missed pivot(s)
  187. ************************* */
  189. // -- Start at last bar. Reestablish curBar
  190. curBar = 
  191. IIf(nlastVisBar > 0 AND bUseLastVis, 
  192. nlastVisBar, 
  193. IIf(Status("action")==4 AND nExploreBarIdx > 0, 
  194. nExploreBarIdx,
  195. LastValue(BarIndex()))
  196. );
  198. // -- Make sure I found at least two of each above.
  199. if (nHPivs >= 2 AND nLPivs >= 2) {
  201. lastLPIdx = aLPivIdxs[0];
  202. lastLPL = aLPivLows[0];
  204. lastHPIdx = aHPivIdxs[0];
  205. lastHPH = aHPivHighs[0];
  207. nLastHOrLPivIdx = Max(lastLPIdx, lastHPIdx);
  209. nAddPivsRng = curBar - nLastHOrLPivIdx;
  210. aLLVAfterLastPiv = LLV(L, nAddPivsRng);  
  211. nLLVAfterLastPiv = aLLVAfterLastPiv[curBar];
  212. aLLVIdxAfterLastPiv = LLVBars(L, nAddPivsRng);  
  213. nLLVIdxAfterLastPiv = curBar - aLLVIdxAfterLastPiv[curBar];
  214. aHHVAfterLastPiv = HHV(H, nAddPivsRng); 
  215. nHHVAfterLastPiv = aHHVAfterLastPiv[curBar];
  216. aHHVIdxAfterLastPiv = HHVBars(H, nAddPivsRng); 
  217. nHHVIdxAfterLastPiv = curBar - aHHVIdxAfterLastPiv[curBar];
  219. // -- Later want to add last high pivot only if
  220. //    not in buy mode from last and still in trade
  222. /*
  223. Note - I'm only interested in adding pivots if I'm in 
  224. a higher-highs or lower-lows scenario
  225. */
  228. // -- OK, let's start where the last high pivot occurs after the
  229. //    last Low pivot
  230. if (lastHPIdx > lastLPIdx) {
  232. /* There are at least two possibilities here. One is that
  233.     the previous high was higher, indicating that this is a 
  234.     possible short retracement or one in the making.
  235.     The other is that the previous high was lower, indicating 
  236.     that this is a possible long retracement in the working. 
  237. However, both depend on opposing pivots. E.g., if I find 
  238. higher highs, what if I have lower lows?  
  240. If the highs are descending, then I can consider:
  241.     - a lower low, and leave it at that
  242.     - a higher high and higher low
  243.     - a lower low and another lower high
  244. */
  245. if (aHPivHighs[0] < aHPivHighs[1]) {
  247. if (nLLVAfterLastPiv < aLPivLows[0] AND 
  248. (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
  249. AND nLLVIdxAfterLastPiv != curBar ) {
  251. // -- OK, we'll add this as a pivot. 
  252. //    Mark it for plotting...
  253. aLPivs[nLLVIdxAfterLastPiv] = 1;
  254. aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
  256. //    ...and then rearrange elements in the 
  257. //    pivot information arrays
  258. for (j=0; j<nLPivs; j++) {
  259. aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  260. aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  261. }
  262. aLPivLows[0] = nLLVAfterLastPiv;
  263. aLPivIdxs[0] = nLLVIdxAfterLastPiv;
  264. nLPivs++;
  266. // -- Test whether to add piv given last piv is high 
  267. //    AND we have lower highs
  268. }
  270. // -- Here, the last piv is a high piv, and we have 
  271. //    higher-highs. The most likely addition is a 
  272. //    Low piv that is a retracement.
  273. } else {
  275. if (nLLVAfterLastPiv > aLPivLows[0] AND 
  276. (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
  277. AND nLLVIdxAfterLastPiv != curBar ) {
  279. // -- OK, we'll add this as a pivot. 
  280. //    Mark it for plotting...
  281. aLPivs[nLLVIdxAfterLastPiv] = 1;
  282. aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
  284. //    ...and then rearrange elements in the 
  285. //    pivot information arrays
  286. for (j=0; j<nLPivs; j++) {
  287. aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  288. aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  289. }
  290. aLPivLows[0] = nLLVAfterLastPiv;
  291. aLPivIdxs[0] = nLLVIdxAfterLastPiv;
  292. nLPivs++;
  294. // -- Test whether to add piv given last piv is high 
  295. //    AND we have lower highs
  296. }
  297. // -- The last piv is a high and we have higher highs 
  298. //    OR lower highs
  299. }
  301. /* ****************************************************************
  302. Still finding missed pivot(s). Here, the last piv is a low piv.
  303. **************************************************************** */
  304. } else {
  306. // -- First case, lower highs
  307. if (aHPivHighs[0] < aHPivHighs[1]) {
  309. if (nHHVAfterLastPiv < aHPivHighs[0] AND 
  310. (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
  311. AND nHHVIdxAfterLastPiv != curBar ) {
  313. // -- OK, we'll add this as a pivot. 
  314. //    Mark that for plotting
  315. aHPivs[nHHVIdxAfterLastPiv] = 1;
  316. aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
  318. //    ...and then rearrange elements in the 
  319. //    pivot information arrays
  320. for (j=0; j<nHPivs; j++) {
  321. aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
  322. aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
  323. }
  324. aHPivHighs[0] = nHHVAfterLastPiv;
  325. aHPivIdxs[0] = nHHVIdxAfterLastPiv;
  326. nHPivs++;
  328. // -- Test whether to add piv given last piv is high 
  329. //    AND we have lower highs
  330. }
  332. // -- Second case when last piv is a low piv, higher highs 
  333. //    Most likely addition is high piv that is a retracement.
  334. //    Considering adding a high piv as long as it is higher
  335. } else {
  337. // -- Where I have higher highs,
  338. if (nHHVAfterLastPiv > aHPivHighs[0] AND 
  339. (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
  340. AND nHHVIdxAfterLastPiv != curBar ) {
  342. // -- OK, we'll add this as a pivot. 
  343. //    Mark it for plotting...
  344. aHPivs[nHHVIdxAfterLastPiv] = 1;
  345. aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
  347. //    ...and then rearrange elements in the 
  348. //    pivot information arrays
  349. for (j=0; j<nHPivs; j++) {
  350. aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
  351. aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
  352. }
  353. aHPivHighs[0] = nHHVAfterLastPiv;
  354. aHPivIdxs[0] = nHHVIdxAfterLastPiv;
  355. nHPivs++;
  357. // -- Test whether to add piv given last piv is high 
  358. //    AND we have lower highs
  359. }
  361. }
  363. } 
  365. // -- If there are at least two of each
  366. }
  368. /* ****************************************
  369. // -- Done with finding pivots
  370. ***************************************** */ 
  372. if (bDraw) {
  374. // -- OK, let's plot the pivots using arrows
  375. PlotShapes(
  376. IIf(aHPivs==1, shapeDownArrow, shapeNone), 
  377. colorRed, 0,  High, Offset=-15);
  378. PlotShapes(
  379. IIf(aAddedHPivs==1, shapeDownArrow, shapeNone),
  380. colorDarkRed, 0, High, Offset=-15);
  381. PlotShapes(
  382. IIf(aLPivs==1, shapeUpArrow , shapeNone),
  383. colorGreen, 0, Low, Offset=-15);
  384. PlotShapes(
  385. IIf(aAddedLPivs==1, shapeUpArrow , shapeNone), 
  386. colorDarkGreen, 0, Low, Offset=-15);
  387. }
  389. /* ****************************************
  390. // -- Done with discovering and plotting pivots 
  391. ***************************************** */ 
  393. // -- I'm going to want to look for possible retracement
  394. risk = 0;
  395. profInc = 0;
  396. nLeg0Pts = 0;
  397. nLeg0Bars = 0;
  398. nLeg0Vol = 0;
  399. nLeg1Pts = 0;
  400. nLeg1Bars = 0;
  401. nLeg1Vol = 0;
  402. nLegBarsDiff = 0;
  403. nRtrc0Pts = 0;
  404. nRtrc0Bars = 0;
  405. nRtrc0Vol = 0;
  406. nRtrc1Pts = 0;
  407. nRtrc1Bars = 0;
  408. nRtrc1Vol = 0;
  410. minRtrc = 0;
  411. maxRtrc = 0;
  412. minLine = 0;
  413. maxLine = 0;
  414. triggerLine = 0;
  415. firstProfitLine = 0;
  416. triggerInc = 0;
  417. triggerPrc = 0;
  418. firstProfitPrc = 0;
  419. retrcPrc = 0;
  420. retrcBar = 0;
  421. retrcBarIdx = 0;
  422. retrcRng = 0;
  423. aRetrcPrc = H-H;
  424. aRetrcPrcBars = H-H;
  425. aRetrcClose = C;
  426. retrcClose = 0;
  428. // -- Do TCZ calcs. Arrangement of pivs very specific
  429. //    for this setup.
  430. if (nHPivs >= 2 AND 
  431. nLPivs >=2 AND  
  432. aHPivHighs[0] > aHPivHighs[1] AND
  433. aLPivLows[0] > aLPivLows[1]) {
  435. tcz500 = 
  436. (aHPivHighs[0] -
  437. (.5 * (aHPivHighs[0] - aLPivLows[1])));
  439. tcz618 = 
  440. (aHPivHighs[0] -
  441. (.618 * (aHPivHighs[0] - aLPivLows[1])));
  443. tcz786 = 
  444. (aHPivHighs[0] -
  445. (.786 * (aHPivHighs[0] - aLPivLows[0])));
  447. retrcRng = curBar  - aHPivIdxs[0];
  448. aRetrcPrc = LLV(L, retrcRng);
  449. retrcPrc = aRetrcPrc[curBar];
  450. aRetrcPrcBars  = LLVBars(L, retrcRng);
  451. retrcBarIdx = curBar - aRetrcPrcBars[curBar];
  452. retrcClose = aRetrcClose[retrcBarIdx];
  454. // -- bTCZLong setup?
  455. bTCZLong = (
  457. // -- Are retracement levels arranged in
  458. //    tcz order?
  459. tcz500 >= (tcz786 * (1 - tczTolerance))
  460. AND 
  461. // .681 is below .786 for long setups
  462. tcz618 <= (tcz786 * (1 + tczTolerance))
  463. AND
  465. // -- Is the low in the tcz range
  466. // -- Is the close >= low of tcz range
  467. //    and low <= high of tcz range
  468. retrcClose >= ((1 - retrcTolerance) *  tcz618)
  469. AND
  470. retrcPrc <= ((1 + retrcTolerance) *  tcz500)
  471. ); 
  473. // -- risk would be high of signal bar minus low of zone
  474. //risk = 0;
  476. // -- lower highs and lower lows
  477. } else if (nHPivs >= 2 AND nLPivs >=2 
  478. AND aHPivHighs[0] < aHPivHighs[1] 
  479. AND aLPivLows[0] < aLPivLows[1]) {
  481. tcz500 = 
  482. (aHPivHighs[1] -
  483. (.5 * (aHPivHighs[1] - aLPivLows[0])));
  485. tcz618 = 
  486. (aHPivHighs[0] -
  487. (.618 * (aHPivHighs[1] - aLPivLows[0])));
  489. tcz786 = 
  490. (aHPivHighs[0] -
  491. (.786 * (aHPivHighs[0] - aLPivLows[0])));
  493. retrcRng = curBar  - aLPivIdxs[0];
  494. aRetrcPrc = HHV(H, retrcRng);
  495. retrcPrc = aRetrcPrc[curBar];
  496. aRetrcPrcBars  = HHVBars(H, retrcRng);
  497. retrcBarIdx = curBar - aRetrcPrcBars[curBar];
  498. retrcClose = aRetrcClose[retrcBarIdx];
  500. bTCZShort = (
  501. // -- Are retracement levels arranged in
  502. //    tcz order?
  504. // .500 is below .786 for short setups
  505. tcz500 <= (tcz786 * (1 + tczTolerance))
  506. AND
  507. // .681 is above .786 for short setups
  508. tcz618 >= (tcz786 * (1 - tczTolerance)) 
  509. AND
  511. // -- Is the close <= high of tcz range
  512. //    and high >= low of tcz range
  513. retrcClose <= ((1 + retrcTolerance) *  tcz618)
  514. AND
  515. retrcPrc >= ((1 - retrcTolerance) *  tcz500)
  516. ); 
  518. // -- Risk would be top of zone - low of signal bar 
  519. //risk = 0;
  520. }
  522. Filter = (bTCZShort OR bTCZLong);
  523. AddColumn(C, "Close");
  524. AddColumn(IIf(bTCZLong, 76, 83), "L/S", formatChar);
  526. // **************************
  527. // END EXPLORATION CODE
  528. // **************************
  530. // **************************
  531. // BEGIN INDICATOR CODE
  532. // **************************
  534. // -- what will be our lookback range for the hh and ll?
  535. nBars = Param("Number of bars", 12, 5, 40);
  536. bTrace = Param("Include trace output", 1, 0, 1);
  537. nNoPivsInSetup = Param("No. Pivs in Setup", 4, 3, 4, 1);
  538. bShowTCZ = Param("Show TCZ", 1, 0, 1); 
  539. nMinBarsBtwPivs = Param("Min. number of bars btw. pivots", 1, 1, 10, 1);
  540. nMinPctBtwPivs = Param("Min. percent diff. btw. pivots", .05, .04, .2, .01);
  541. bLastBarCanBePiv = Param("Last bar can be a pivot", 1, 0, 1); 
  542. retrcTolerance = .01;
  543. tczTolerance = .005;
  544. nNumBarsToScan = 120;
  546. // -- added from exploration version 20040204
  547. nExploreBarIdx = 0;
  548. nExploreDate = 0;
  549. nCurDateNum = 0;
  550. DN = DateNum();
  551. DT = DateTime();
  553. // -- key exploration variables
  554. bTCZLong = False;
  555. bTCZShort = False;
  556. nAnchorPivIdx = 0;
  558. ADX8 = ADX(8);
  560. // 1 - INDICATOR, 2 - COMMENTARY, 3 - SCAN, 
  561. // 4 - EXPLORATION, 5 - BACKTEST / Optimize 
  562. if(Status("action")==1) {
  563. bDraw = True;
  564. bUseLastVis = Param("Use last visible bar", 1, 0, 1);
  565. } else {
  566. bDraw = False;
  567. bUseLastVis = False;
  568. bTrace = False;
  569. nExploreDate = Status("rangetodate");
  570. for (i=LastValue(BarIndex());i>=0;i--) {
  571. nCurDateNum = DN[i];
  572. if (nCurDateNum == nExploreDate) {
  573. nExploreBarIdx = i;
  574. }
  575. }
  576. // -- if(Status("action")==1...
  577. }
  579. GraphXSpace=7;
  581. // -- basic candle chart
  582. // -- if this appears inside if block, strange
  583. //    drawing results!
  584. PlotOHLC(Open, High, Low, Close, 
  585. "BIdx = " + BarIndex() + 
  586. "n" + "O = " + O + "n"+"H = "+ H + "n"+"L  = " + L 
  587. + "n"+"C ",
  588. colorBlack, styleCandle); 
  590. if (bDraw) {
  591. Plot(MA(C, 21), "21 bar MA", colorAqua, 
  592. styleLine+styleNoRescale+styleNoLabel);
  593. Plot(MA(C, 55), "55 bar MA", colorGreen, 
  594. styleLine+styleNoRescale+styleNoLabel);
  595. //Plot(MA(C, 233), "233 bar MA", colorDarkRed, 
  596. // styleLine+styleNoRescale+styleNoLabel);
  597. }
  599. // -- Create 0-initialized arrays the size of barcount
  600. aHPivs = H - H;
  601. aLPivs = L - L;
  602. aHPivHighs = H - H;
  603. aLPivLows = L - L;
  604. aHPivIdxs = H - H;
  605. aLPivIdxs = L - L;
  606. aAddedHPivs = H - H;
  607. aAddedLPivs = L - L;
  608. aLegVol = H - H;
  609. aRetrcVol = H - H;
  611. nHPivs = 0;
  612. nLPivs = 0;
  614. lastHPIdx = 0;
  615. lastLPIdx = 0;
  616. lastHPH = 0;
  617. lastLPL = 0;
  618. curPivBarIdx = 0;
  620. // -- looking back from the current bar, how many bars 
  621. //    back were the hhv and llv values of the previous 
  622. //    n bars, etc.?
  623. aHHVBars = HHVBars(H, nBars);
  624. aLLVBars = LLVBars(L, nBars);
  625. aHHV = HHV(H, nBars);
  626. aLLV = LLV(L, nBars);
  628. // -- Initialize value of curTrend
  629. nLastVisBar = LastValue(
  630. Highest(IIf(Status("barvisible"), BarIndex(), 0)));
  632. curBar = IIf(nlastVisBar > 0 AND bUseLastVis, nlastVisBar, 
  633. IIf(Status("action")==4 AND nExploreBarIdx > 0, nExploreBarIdx,
  634. LastValue(BarIndex())));
  636. curTrend = "";
  637. if (aLLVBars[curBar] < aHHVBars[curBar]) 
  638. curTrend = "D";
  639. else 
  640. curTrend = "U";
  642. // -- Loop through bars. Search for 
  643. //    entirely array-based approach
  644. //    in future version
  645. /* *******************
  646. Find main pivots
  647. ******************* */
  649. // -- Make sure there are enough bars!
  650. if (curBar >= nNumBarsToScan) {
  651. for (i=0; i<nNumBarsToScan; i++) {
  653. // -- value of curBar dependent on two parameters
  654. curBar = IIf(nlastVisBar > 0 AND bUseLastVis, 
  655. nlastVisBar-i, 
  656. IIf(Status("action")==4 AND nExploreBarIdx > 0, 
  657. nExploreBarIdx-i,
  658. LastValue(BarIndex())-i));
  660. // -- Have we identified a pivot? If trend is down...
  661. if (aLLVBars[curBar] < aHHVBars[curBar]) {
  663. // ... and had been up, this is a trend change
  664. if (curTrend == "U") {
  665. curTrend = "D";
  666. // -- Capture pivot information
  667. curPivBarIdx = curBar - aLLVBars[curBar];
  668. aLPivs[curPivBarIdx] = 1;
  669. aLPivLows[nLPivs] = L[curPivBarIdx];
  670. aLPivIdxs[nLPivs] = curPivBarIdx;
  671. nLPivs++;
  672. }
  673. // -- or current trend is up
  674. } else {
  675. if (curTrend == "D") {
  676. curTrend = "U";
  677. curPivBarIdx = curBar - aHHVBars[curBar];
  678. aHPivs[curPivBarIdx] = 1;
  679. aHPivHighs[nHPivs] = H[curPivBarIdx];
  680. aHPivIdxs[nHPivs] = curPivBarIdx;
  681. nHPivs++;
  682. }
  683. // --  If curTrend is up...else...
  684. }
  686. // -- loop through bars
  687. } 
  688. }
  689. /* *******************
  690. Found main pivots
  691. ******************* */
  693. /* *************************
  694. Finding missed pivot(s)
  695. ************************* */
  697. // -- Start at last bar. Reestablish curBar
  698. curBar = 
  699. IIf(nlastVisBar > 0 AND bUseLastVis, 
  700. nlastVisBar, 
  701. IIf(Status("action")==4 AND nExploreBarIdx > 0, 
  702. nExploreBarIdx,
  703. LastValue(BarIndex()))
  704. );
  706. // -- Make sure I found at least two of each above.
  707. if (nHPivs >= 2 AND nLPivs >= 2) {
  709. lastLPIdx = aLPivIdxs[0];
  710. lastLPL = aLPivLows[0];
  712. lastHPIdx = aHPivIdxs[0];
  713. lastHPH = aHPivHighs[0];
  715. nLastHOrLPivIdx = Max(lastLPIdx, lastHPIdx);
  717. nAddPivsRng = curBar - nLastHOrLPivIdx;
  718. aLLVAfterLastPiv = LLV(L, nAddPivsRng);  
  719. nLLVAfterLastPiv = aLLVAfterLastPiv[curBar];
  720. aLLVIdxAfterLastPiv = LLVBars(L, nAddPivsRng);  
  721. nLLVIdxAfterLastPiv = curBar - aLLVIdxAfterLastPiv[curBar];
  722. aHHVAfterLastPiv = HHV(H, nAddPivsRng); 
  723. nHHVAfterLastPiv = aHHVAfterLastPiv[curBar];
  724. aHHVIdxAfterLastPiv = HHVBars(H, nAddPivsRng); 
  725. nHHVIdxAfterLastPiv = curBar - aHHVIdxAfterLastPiv[curBar];
  727. // -- Later want to add last high pivot only if
  728. //    not in buy mode from last and still in trade
  730. /*
  731. Note - I'm only interested in adding pivots if I'm in 
  732. a higher-highs or lower-lows scenario
  733. */
  736. // -- OK, let's start where the last high pivot occurs after the
  737. //    last Low pivot
  738. if (lastHPIdx > lastLPIdx) {
  740. /* There are at least two possibilities here. One is that
  741.     the previous high was higher, indicating that this is a 
  742.     possible short retracement or one in the making.
  743.     The other is that the previous high was lower, indicating 
  744.     that this is a possible long retracement in the working. 
  745. However, both depend on opposing pivots. E.g., if I find 
  746. higher highs, what if I have lower lows?  
  748. If the highs are descending, then I can consider:
  749.     - a lower low, and leave it at that
  750.     - a higher high and higher low
  751.     - a lower low and another lower high
  752. */
  753. if (aHPivHighs[0] < aHPivHighs[1]) {
  755. if (nLLVAfterLastPiv < aLPivLows[0] AND 
  756. (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
  757. AND nLLVIdxAfterLastPiv != curBar ) {
  759. // -- OK, we'll add this as a pivot. 
  760. //    Mark it for plotting...
  761. aLPivs[nLLVIdxAfterLastPiv] = 1;
  762. aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
  764. //    ...and then rearrange elements in the 
  765. //    pivot information arrays
  766. for (j=0; j<nLPivs; j++) {
  767. aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  768. aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  769. }
  770. aLPivLows[0] = nLLVAfterLastPiv;
  771. aLPivIdxs[0] = nLLVIdxAfterLastPiv;
  772. nLPivs++;
  774. // -- Test whether to add piv given last piv is high 
  775. //    AND we have lower highs
  776. }
  778. // -- Here, the last piv is a high piv, and we have 
  779. //    higher-highs. The most likely addition is a 
  780. //    Low piv that is a retracement.
  781. } else {
  783. if (nLLVAfterLastPiv > aLPivLows[0] AND 
  784. (nLLVIdxAfterLastPiv - lastHPIdx - 1) >= nMinBarsBtwPivs
  785. AND nLLVIdxAfterLastPiv != curBar ) {
  787. // -- OK, we'll add this as a pivot. 
  788. //    Mark it for plotting...
  789. aLPivs[nLLVIdxAfterLastPiv] = 1;
  790. aAddedLPivs[nLLVIdxAfterLastPiv] = 1;
  792. //    ...and then rearrange elements in the 
  793. //    pivot information arrays
  794. for (j=0; j<nLPivs; j++) {
  795. aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  796. aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  797. }
  798. aLPivLows[0] = nLLVAfterLastPiv;
  799. aLPivIdxs[0] = nLLVIdxAfterLastPiv;
  800. nLPivs++;
  802. // -- Test whether to add piv given last piv is high 
  803. //    AND we have lower highs
  804. }
  805. // -- The last piv is a high and we have higher highs 
  806. //    OR lower highs
  807. }
  809. /* ****************************************************************
  810. Still finding missed pivot(s). Here, the last piv is a low piv.
  811. **************************************************************** */
  812. } else {
  814. // -- First case, lower highs
  815. if (aHPivHighs[0] < aHPivHighs[1]) {
  817. if (nHHVAfterLastPiv < aHPivHighs[0] AND 
  818. (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
  819. AND nHHVIdxAfterLastPiv != curBar ) {
  821. // -- OK, we'll add this as a pivot. 
  822. //    Mark that for plotting
  823. aHPivs[nHHVIdxAfterLastPiv] = 1;
  824. aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
  826. //    ...and then rearrange elements in the 
  827. //    pivot information arrays
  828. for (j=0; j<nHPivs; j++) {
  829. aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
  830. aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
  831. }
  832. aHPivHighs[0] = nHHVAfterLastPiv;
  833. aHPivIdxs[0] = nHHVIdxAfterLastPiv;
  834. nHPivs++;
  836. // -- Test whether to add piv given last piv is high 
  837. //    AND we have lower highs
  838. }
  840. // -- Second case when last piv is a low piv, higher highs 
  841. //    Most likely addition is high piv that is a retracement.
  842. //    Considering adding a high piv as long as it is higher
  843. } else {
  845. // -- Where I have higher highs,
  846. if (nHHVAfterLastPiv > aHPivHighs[0] AND 
  847. (nHHVIdxAfterLastPiv - lastLPIdx - 1) >= nMinBarsBtwPivs
  848. AND nHHVIdxAfterLastPiv != curBar ) {
  850. // -- OK, we'll add this as a pivot. 
  851. //    Mark it for plotting...
  852. aHPivs[nHHVIdxAfterLastPiv] = 1;
  853. aAddedHPivs[nHHVIdxAfterLastPiv] = 1;
  855. //    ...and then rearrange elements in the 
  856. //    pivot information arrays
  857. for (j=0; j<nHPivs; j++) {
  858. aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-(j+1)];
  859. aHPivIdxs[nHPivs-j] = aHPivIdxs[nhPivs-(j+1)];
  860. }
  861. aHPivHighs[0] = nHHVAfterLastPiv;
  862. aHPivIdxs[0] = nHHVIdxAfterLastPiv;
  863. nHPivs++;
  865. // -- Test whether to add piv given last piv is high 
  866. //    AND we have lower highs
  867. }
  869. }
  871. } 
  873. // -- If there are at least two of each
  874. }
  876. /* ****************************************
  877. // -- Done with finding pivots
  878. ***************************************** */ 
  880. if (bDraw) {
  882. // -- OK, let's plot the pivots using arrows
  883. PlotShapes(
  884. IIf(aHPivs==1, shapeDownArrow, shapeNone), 
  885. colorRed, 0,  High, Offset=-15);
  886. PlotShapes(
  887. IIf(aAddedHPivs==1, shapeDownArrow, shapeNone),
  888. colorDarkRed, 0, High, Offset=-15);
  889. PlotShapes(
  890. IIf(aLPivs==1, shapeUpArrow , shapeNone),
  891. colorGreen, 0, Low, Offset=-15);
  892. PlotShapes(
  893. IIf(aAddedLPivs==1, shapeUpArrow , shapeNone), 
  894. colorDarkGreen, 0, Low, Offset=-15);
  895. }
  897. /* ****************************************
  898. // -- Done with discovering and plotting pivots 
  899. ***************************************** */ 
  901. // -- I'm going to want to look for possible retracement
  902. risk = 0;
  903. profInc = 0;
  904. nLeg0Pts = 0;
  905. nLeg0Bars = 0;
  906. nLeg0Vol = 0;
  907. nLeg1Pts = 0;
  908. nLeg1Bars = 0;
  909. nLeg1Vol = 0;
  910. nLegBarsDiff = 0;
  911. nRtrc0Pts = 0;
  912. nRtrc0Bars = 0;
  913. nRtrc0Vol = 0;
  914. nRtrc1Pts = 0;
  915. nRtrc1Bars = 0;
  916. nRtrc1Vol = 0;
  918. minRtrc = 0;
  919. maxRtrc = 0;
  920. minLine = 0;
  921. maxLine = 0;
  922. triggerLine = 0;
  923. firstProfitLine = 0;
  924. triggerInc = 0;
  925. triggerPrc = 0;
  926. firstProfitPrc = 0;
  927. retrcPrc = 0;
  928. retrcBar = 0;
  929. retrcBarIdx = 0;
  930. retrcRng = 0;
  931. aRetrcPrc = H-H;
  932. aRetrcPrcBars = H-H;
  933. aRetrcClose = C;
  934. retrcClose = 0;
  936. // -- Do TCZ calcs. Arrangement of pivs very specific
  937. //    for this setup.
  938. if (nHPivs >= 2 AND 
  939. nLPivs >=2 AND  
  940. aHPivHighs[0] > aHPivHighs[1] AND
  941. aLPivLows[0] > aLPivLows[1]) {
  943. tcz500 = 
  944. (aHPivHighs[0] -
  945. (.5 * (aHPivHighs[0] - aLPivLows[1])));
  947. tcz618 = 
  948. (aHPivHighs[0] -
  949. (.618 * (aHPivHighs[0] - aLPivLows[1])));
  951. tcz786 = 
  952. (aHPivHighs[0] -
  953. (.786 * (aHPivHighs[0] - aLPivLows[0])));
  955. retrcRng = curBar  - aHPivIdxs[0];
  956. aRetrcPrc = LLV(L, retrcRng);
  957. aRetrcPrcBars  = LLVBars(L, retrcRng);
  959. retrcPrc = aRetrcPrc[curBar];
  960. retrcBarIdx = curBar - aRetrcPrcBars[curBar];
  961. retrcClose = aRetrcClose[retrcBarIdx];
  963. // -- bTCZLong setup?
  964. bTCZLong = (
  966. // -- Are retracement levels arranged in
  967. //    tcz order?
  969. // .500 is above .786 for long setups
  970. tcz500 >= (tcz786 * (1 - tczTolerance))
  971. AND 
  972. // .681 is below .786 for long setups
  973. tcz618 <= (tcz786 * (1 + tczTolerance))
  974. AND
  976. // -- Is the low in the tcz range
  977. // -- Is the close >= low of tcz range
  978. //    and low <= high of tcz range
  979. retrcClose >= ((1 - retrcTolerance) *  tcz618)
  980. AND
  981. retrcPrc <= ((1 + retrcTolerance) *  tcz500)
  982. ); 
  984. // -- risk would be high of signal bar minus low of zone
  985. //risk = 0;
  987. // -- lower highs and lower lows
  988. } else if (nHPivs >= 2 AND nLPivs >=2 
  989. AND aHPivHighs[0] < aHPivHighs[1] 
  990. AND aLPivLows[0] < aLPivLows[1]) {
  992. tcz500 = 
  993. (aHPivHighs[1] -
  994. (.5 * (aHPivHighs[1] - aLPivLows[0])));
  996. tcz618 = 
  997. (aHPivHighs[0] -
  998. (.618 * (aHPivHighs[1] - aLPivLows[0])));
  1000. tcz786 = 
  1001. (aHPivHighs[0] -
  1002. (.786 * (aHPivHighs[0] - aLPivLows[0])));
  1004. retrcRng = curBar  - aLPivIdxs[0];
  1005. aRetrcPrc = HHV(H, retrcRng);
  1006. retrcPrc = aRetrcPrc[curBar];
  1007. aRetrcPrcBars  = HHVBars(H, retrcRng);
  1008. retrcBarIdx = curBar - aRetrcPrcBars[curBar];
  1009. retrcClose = aRetrcClose[retrcBarIdx];
  1011. bTCZShort = (
  1012. // -- Are retracement levels arranged in
  1013. //    tcz order?
  1015. // .500 is below .786 for short setups
  1016. tcz500 <= (tcz786 * (1 + tczTolerance))
  1017. AND
  1018. // .681 is above .786 for short setups
  1019. tcz618 >= (tcz786 * (1 - tczTolerance)) 
  1020. AND
  1022. // -- Is the close <= high of tcz range
  1023. //    and high >= low of tcz range
  1024. retrcClose <= ((1 + retrcTolerance) *  tcz618)
  1025. AND
  1026. retrcPrc >= ((1 - retrcTolerance) *  tcz500)
  1027. ); 
  1029. // -- Risk would be top of zone - low of signal bar 
  1030. //risk = 0;
  1031. }
  1033. // -- Show zone if present
  1034. if (bTCZShort OR bTCZLong) { 
  1036. // -- Be prepared to see symmetry
  1037. if (bTCZShort) {
  1038. if (aLPivIdxs[0] > aHPivIdxs[0]) {
  1039. // -- Valuable, useful symmetry information 
  1040. nRtrc0Pts = aHPivHighs[0] - aLPivLows[1];
  1041. nRtrc0Bars = aHPivIdxs[0] - aLPivIdxs[1] + 1;
  1042. nRtrc1Pts = retrcPrc - aLPivLows[0];
  1043. nRtrc1Bars = retrcBarIdx - aLPivIdxs[0] + 1;
  1044. } else {
  1045. nRtrc0Pts = aHPivHighs[1] - aLPivLows[1];
  1046. nRtrc0Bars = aHPivIdxs[1] - aLPivIdxs[1] + 1;
  1047. nRtrc1Pts = aHPivHighs[0] - aLPivLows[0];
  1048. nRtrc1Bars = aHPivIdxs[0] - aLPivIdxs[0] + 1;
  1049. }
  1050. } else { // bLongSetup
  1051. if (aLPivIdxs[0] > aHPivIdxs[0]) {
  1052. nRtrc0Pts = aHPivHighs[0] - aLPivLows[1];
  1053. nRtrc0Bars = aHPivIdxs[0] - aLPivIdxs[1] + 1;
  1054. nRtrc1Pts = retrcPrc - aLPivLows[0];
  1055. nRtrc1Bars = retrcBarIdx - aLPivIdxs[0] + 1;
  1056. } else {
  1057. nRtrc0Pts = aHPivHighs[1] - aLPivLows[0];
  1058. nRtrc0Bars = aLPivIdxs[0] - aHPivIdxs[1] + 1;
  1059. nRtrc1Pts = aHPivHighs[0] - aLPivLows[0];
  1060. nRtrc1Bars = aLPivIdxs[0] - aHPivIdxs[0] + 1;
  1061. }
  1062. }
  1064. if (bShowTCZ) {
  1065. Plot(
  1066. LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
  1067. tcz500, curBar, tcz500 , 0), 
  1068. "tcz500", colorPaleBlue, styleLine);
  1069. Plot(
  1070. LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
  1071. tcz618, curBar, tcz618, 0), 
  1072. "tcz618", colorPaleBlue, styleLine);
  1073. Plot(
  1074. LineArray( IIf(bTCZLong, aHPivIdxs[0], aLPivIdxs[0]),
  1075. tcz786, curBar, tcz786, 0), 
  1076. "tcz786", colorTurquoise, styleLine);
  1077. }
  1079. // -- if (bShowTCZ)
  1080. }
  1082. if (bDraw) {
  1083. Title = Name() + " (" + StrLeft(FullName(), 10) + 
  1084. ")  ATR: " + NumToStr(ATR(1), 4.2) + " ( " + 
  1085. NumToStr((C - Ref(C, -1)), 4.2) + " / " +
  1086. NumToStr((((C - Ref(C, -1)) / Ref(C, -1)) * 100), 2.1) +  "% )  " +
  1087. WriteVal( SelectedValue( DateTime() ), formatDateTime) +
  1088. " nO: " + Open + 
  1089. ",  nH: " + High + 
  1090. ",  nL: " + Low + 
  1091. ", nC: " + Close +  ",  n" +
  1092. // "Risk: " + WriteVal(risk, 2.1) + "%  n" +
  1093. "Rtrc 0/1 Pts: " + WriteVal(nRtrc0Pts, 2.1) + "/" + 
  1094. WriteVal(nRtrc1Pts, 2.1) + "  n" +
  1095. "Rtrc 0/1 Bars: " + WriteVal(nRtrc0Bars, 2.0) + "/" +
  1096. WriteVal(nRtrc1Bars, 2.0);
  1097. }
  1099. // **************************
  1100. // END INDICATOR CODE
  1101. // **************************