Pivot Finder.afl
上传用户:shiqiang
上传日期:2009-06-12
资源大小:1289k
文件大小:11k
源码类别:

金融证券系统

开发平台:

Others

  1. //------------------------------------------------------------------------------
  2. //
  3. //  Formula Name:    Pivot Finder
  4. //  Author/Uploader: Mark 
  5. //  E-mail:          
  6. //  Date/Time Added: 2004-07-19 01:06:36
  7. //  Origin:          This has got to be one of the best pivot finders I have found yet.  Nobody knows the author who wrote it.... Whoever you are thanks a bunch!!
  8. //  Keywords:        
  9. //  Level:           semi-advanced
  10. //  Flags:           indicator
  11. //  Formula URL:     http://www.amibroker.com/library/formula.php?id=359
  12. //  Details URL:     http://www.amibroker.com/library/detail.php?id=359
  13. //
  14. //------------------------------------------------------------------------------
  15. //
  16. //  /* **********************************
  17. //
  18. //  Code to automatically identify pivots
  19. //
  20. //  ********************************** */
  21. //
  22. //  // -- what will be our lookback range for the hh and ll?
  23. //
  24. //  farback=Param("How Far back to go",100,50,5000,10);
  25. //
  26. //  nBars = Param("Number of bars", 12, 5, 40);
  27. //
  28. //  // -- Title.
  29. //
  30. //  Title = Name() + " (" + StrLeft(FullName(), 15) + ") O: " + Open + ",
  31. //
  32. //  H: " + High + ", L: " + Low + ", C: " + Close;
  33. //
  34. //  // -- Plot basic candle chart
  35. //
  36. //  PlotOHLC(Open, High, Low, Close,
  37. //
  38. //  "BIdx = " + BarIndex() +
  39. //
  40. //  "n" + "O = " + O + "n"+"H = "+ H + "n"+"L = " + L
  41. //
  42. //  + "n"+"C ",
  43. //
  44. //  colorBlack, styleCandle);
  45. //
  46. //  GraphXSpace=7;
  47. //
  48. //  // -- Create 0-initialized arrays the size of barcount
  49. //
  50. //  aHPivs = H - H;
  51. //
  52. //  aLPivs = L - L;
  53. //
  54. //  // -- More for future use, not necessary for basic plotting
  55. //
  56. //  aHPivHighs = H - H;
  57. //
  58. //  aLPivLows = L - L;
  59. //
  60. //  aHPivIdxs = H - H;
  61. //
  62. //  aLPivIdxs = L - L;
  63. //
  64. //  nHPivs = 0;
  65. //
  66. //  nLPivs = 0;
  67. //
  68. //  lastHPIdx = 0;
  69. //
  70. //  lastLPIdx = 0;
  71. //
  72. //  lastHPH = 0;
  73. //
  74. //  lastLPL = 0;
  75. //
  76. //  curPivBarIdx = 0;
  77. //
  78. //  // -- looking back from the current bar, how many bars
  79. //
  80. //  // back were the hhv and llv values of the previous
  81. //
  82. //  // n bars, etc.?
  83. //
  84. //  aHHVBars = HHVBars(H, nBars);
  85. //
  86. //  aLLVBars = LLVBars(L, nBars);
  87. //
  88. //  aHHV = HHV(H, nBars);
  89. //
  90. //  aLLV = LLV(L, nBars);
  91. //
  92. //  // -- Would like to set this up so pivots are calculated back from
  93. //
  94. //  // last visible bar to make it easy to "go back" and see the pivots
  95. //
  96. //  // this code would find. However, the first instance of
  97. //
  98. //  // _Trace output will show a value of 0
  99. //
  100. //  aVisBars = Status("barvisible");
  101. //
  102. //  nLastVisBar = LastValue(Highest(IIf(aVisBars, BarIndex(), 0)));
  103. //
  104. //  _TRACE("Last visible bar: " + nLastVisBar);
  105. //
  106. //  // -- Initialize value of curTrend
  107. //
  108. //  curBar = (BarCount-1);
  109. //
  110. //  curTrend = "";
  111. //
  112. //  if (aLLVBars[curBar] <
  113. //
  114. //  aHHVBars[curBar]) {
  115. //
  116. //  curTrend = "D";
  117. //
  118. //  }
  119. //
  120. //  else {
  121. //
  122. //  curTrend = "U";
  123. //
  124. //  }
  125. //
  126. //  // -- Loop through bars. Search for
  127. //
  128. //  // entirely array-based approach
  129. //
  130. //  // in future version
  131. //
  132. //  for (i=0; i<farback; i++) {
  133. //
  134. //  curBar = (BarCount - 1) - i;
  135. //
  136. //  // -- Have we identified a pivot? If trend is down...
  137. //
  138. //  if (aLLVBars[curBar] < aHHVBars[curBar]) {
  139. //
  140. //  // ... and had been up, this is a trend change
  141. //
  142. //  if (curTrend == "U") {
  143. //
  144. //  curTrend = "D";
  145. //
  146. //  // -- Capture pivot information
  147. //
  148. //  curPivBarIdx = curBar - aLLVBars[curBar];
  149. //
  150. //  aLPivs[curPivBarIdx] = 1;
  151. //
  152. //  aLPivLows[nLPivs] = L[curPivBarIdx];
  153. //
  154. //  aLPivIdxs[nLPivs] = curPivBarIdx;
  155. //
  156. //  nLPivs++;
  157. //
  158. //  }
  159. //
  160. //  // -- or current trend is up
  161. //
  162. //  } else {
  163. //
  164. //  if (curTrend == "D") {
  165. //
  166. //  curTrend = "U";
  167. //
  168. //  curPivBarIdx = curBar - aHHVBars[curBar];
  169. //
  170. //  aHPivs[curPivBarIdx] = 1;
  171. //
  172. //  aHPivHighs[nHPivs] = H[curPivBarIdx];
  173. //
  174. //  aHPivIdxs[nHPivs] = curPivBarIdx;
  175. //
  176. //  nHPivs++;
  177. //
  178. //  }
  179. //
  180. //  // -- If curTrend is up...else...
  181. //
  182. //  }
  183. //
  184. //  // -- loop through bars
  185. //
  186. //  }
  187. //
  188. //  // -- Basic attempt to add a pivot this logic may have missed
  189. //
  190. //  // -- OK, now I want to look at last two pivots. If the most
  191. //
  192. //  // recent low pivot is after the last high, I could
  193. //
  194. //  // still have a high pivot that I didn't catch
  195. //
  196. //  // -- Start at last bar
  197. //
  198. //  curBar = (BarCount-1);
  199. //
  200. //  candIdx = 0;
  201. //
  202. //  candPrc = 0;
  203. //
  204. //  lastLPIdx = aLPivIdxs[0];
  205. //
  206. //  lastLPL = aLPivLows[0];
  207. //
  208. //  lastHPIdx = aHPivIdxs[0];
  209. //
  210. //  lastHPH = aHPivHighs[0];
  211. //
  212. //  if (lastLPIdx > lastHPIdx) {
  213. //
  214. //  // -- Bar and price info for candidate pivot
  215. //
  216. //  candIdx = curBar - aHHVBars[curBar];
  217. //
  218. //  candPrc = aHHV[curBar];
  219. //
  220. //  if (
  221. //
  222. //  lastHPH < candPrc AND
  223. //
  224. //  candIdx > lastLPIdx AND
  225. //
  226. //  candIdx < curBar) {
  227. //
  228. //  // -- OK, we'll add this as a pivot...
  229. //
  230. //  aHPivs[candIdx] = 1;
  231. //
  232. //  // ...and then rearrange elements in the
  233. //
  234. //  // pivot information arrays
  235. //
  236. //  for (j=0; j<nHPivs; j++) {
  237. //
  238. //  aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-
  239. //
  240. //  (j+1)];
  241. //
  242. //  aHPivIdxs[nHPivs-j] = aHPivIdxs[nHPivs-(j+1)];
  243. //
  244. //  }
  245. //
  246. //  aHPivHighs[0] = candPrc ;
  247. //
  248. //  aHPivIdxs[0] = candIdx;
  249. //
  250. //  nHPivs++;
  251. //
  252. //  }
  253. //
  254. //  } else {
  255. //
  256. //  // -- Bar and price info for candidate pivot
  257. //
  258. //  candIdx = curBar - aLLVBars[curBar];
  259. //
  260. //  candPrc = aLLV[curBar];
  261. //
  262. //  if (
  263. //
  264. //  lastLPL > candPrc AND
  265. //
  266. //  candIdx > lastHPIdx AND
  267. //
  268. //  candIdx < curBar) {
  269. //
  270. //  // -- OK, we'll add this as a pivot...
  271. //
  272. //  aLPivs[candIdx] = 1;
  273. //
  274. //  // ...and then rearrange elements in the
  275. //
  276. //  // pivot information arrays
  277. //
  278. //  for (j=0; j<nLPivs; j++) {
  279. //
  280. //  aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  281. //
  282. //  aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  283. //
  284. //  }
  285. //
  286. //  aLPivLows[0] = candPrc;
  287. //
  288. //  aLPivIdxs[0] = candIdx;
  289. //
  290. //  nLPivs++;
  291. //
  292. //  }
  293. //
  294. //  }
  295. //
  296. //  // -- Dump inventory of high pivots for debugging
  297. //
  298. //  /*
  299. //
  300. //  for (k=0; k<nHPivs; k++) {
  301. //
  302. //  _TRACE("High pivot no. " + k
  303. //
  304. //  + " at barindex: " + aHPivIdxs[k] + ", "
  305. //
  306. //  + WriteVal(ValueWhen(BarIndex()==aHPivIdxs[k],
  307. //
  308. //  DateTime(), 1), formatDateTime)
  309. //
  310. //  + ", " + aHPivHighs[k]);
  311. //
  312. //  }
  313. //
  314. //  */
  315. //
  316. //  // -- OK, let's plot the pivots using arrows
  317. //
  318. //  PlotShapes(
  319. //
  320. //  IIf(aHPivs==1, shapeDownArrow, shapeNone), colorRed, 0,
  321. //
  322. //  High, Offset=-15);
  323. //
  324. //  PlotShapes(
  325. //
  326. //  IIf(aLPivs==1, shapeUpArrow , shapeNone), colorGreen, 0,
  327. //
  328. //  Low, Offset=-15);
  329. //
  330. //------------------------------------------------------------------------------
  331.   /* **********************************
  332. Code to automatically identify pivots
  333. ********************************** */
  334. // -- what will be our lookback range for the hh and ll?
  335. farback=Param("How Far back to go",100,50,5000,10);
  336. nBars = Param("Number of bars", 12, 5, 40);
  337. // -- Title.
  338. Title = Name() + " (" + StrLeft(FullName(), 15) + ") O: " + Open + ", 
  339. H: " + High + ", L: " + Low + ", C: " + Close;
  340. // -- Plot basic candle chart
  341. PlotOHLC(Open, High, Low, Close, 
  342. "BIdx = " + BarIndex() + 
  343. "n" + "O = " + O + "n"+"H = "+ H + "n"+"L = " + L 
  344. + "n"+"C ",
  345. colorBlack, styleCandle); 
  346. GraphXSpace=7;
  347. // -- Create 0-initialized arrays the size of barcount
  348. aHPivs = H - H;
  349. aLPivs = L - L;
  350. // -- More for future use, not necessary for basic plotting
  351. aHPivHighs = H - H;
  352. aLPivLows = L - L;
  353. aHPivIdxs = H - H;
  354. aLPivIdxs = L - L;
  355. nHPivs = 0;
  356. nLPivs = 0;
  357. lastHPIdx = 0;
  358. lastLPIdx = 0;
  359. lastHPH = 0;
  360. lastLPL = 0;
  361. curPivBarIdx = 0;
  362. // -- looking back from the current bar, how many bars 
  363. // back were the hhv and llv values of the previous 
  364. // n bars, etc.?
  365. aHHVBars = HHVBars(H, nBars);
  366. aLLVBars = LLVBars(L, nBars);
  367. aHHV = HHV(H, nBars);
  368. aLLV = LLV(L, nBars);
  369. // -- Would like to set this up so pivots are calculated back from
  370. // last visible bar to make it easy to "go back" and see the pivots
  371. // this code would find. However, the first instance of 
  372. // _Trace output will show a value of 0
  373. aVisBars = Status("barvisible");
  374. nLastVisBar = LastValue(Highest(IIf(aVisBars, BarIndex(), 0)));
  375. _TRACE("Last visible bar: " + nLastVisBar);
  376. // -- Initialize value of curTrend
  377. curBar = (BarCount-1);
  378. curTrend = "";
  379. if (aLLVBars[curBar] < 
  380. aHHVBars[curBar]) {
  381. curTrend = "D";
  382. }
  383. else {
  384. curTrend = "U";
  385. }
  386. // -- Loop through bars. Search for 
  387. // entirely array-based approach
  388. // in future version
  389. for (i=0; i<farback; i++) {
  390. curBar = (BarCount - 1) - i;
  391. // -- Have we identified a pivot? If trend is down...
  392. if (aLLVBars[curBar] < aHHVBars[curBar]) {
  393. // ... and had been up, this is a trend change
  394. if (curTrend == "U") {
  395. curTrend = "D";
  396. // -- Capture pivot information
  397. curPivBarIdx = curBar - aLLVBars[curBar];
  398. aLPivs[curPivBarIdx] = 1;
  399. aLPivLows[nLPivs] = L[curPivBarIdx];
  400. aLPivIdxs[nLPivs] = curPivBarIdx;
  401. nLPivs++;
  402. }
  403. // -- or current trend is up
  404. } else {
  405. if (curTrend == "D") {
  406. curTrend = "U";
  407. curPivBarIdx = curBar - aHHVBars[curBar];
  408. aHPivs[curPivBarIdx] = 1;
  409. aHPivHighs[nHPivs] = H[curPivBarIdx];
  410. aHPivIdxs[nHPivs] = curPivBarIdx;
  411. nHPivs++;
  412. }
  413. // -- If curTrend is up...else...
  414. // -- loop through bars
  415. // -- Basic attempt to add a pivot this logic may have missed
  416. // -- OK, now I want to look at last two pivots. If the most 
  417. // recent low pivot is after the last high, I could
  418. // still have a high pivot that I didn't catch
  419. // -- Start at last bar
  420. curBar = (BarCount-1);
  421. candIdx = 0;
  422. candPrc = 0;
  423. lastLPIdx = aLPivIdxs[0];
  424. lastLPL = aLPivLows[0];
  425. lastHPIdx = aHPivIdxs[0];
  426. lastHPH = aHPivHighs[0];
  427. if (lastLPIdx > lastHPIdx) {
  428. // -- Bar and price info for candidate pivot
  429. candIdx = curBar - aHHVBars[curBar];
  430. candPrc = aHHV[curBar]; 
  431. if (
  432. lastHPH < candPrc AND
  433. candIdx > lastLPIdx AND
  434. candIdx < curBar) {
  435. // -- OK, we'll add this as a pivot...
  436. aHPivs[candIdx] = 1;
  437. // ...and then rearrange elements in the 
  438. // pivot information arrays
  439. for (j=0; j<nHPivs; j++) {
  440. aHPivHighs[nHPivs-j] = aHPivHighs[nHPivs-
  441. (j+1)];
  442. aHPivIdxs[nHPivs-j] = aHPivIdxs[nHPivs-(j+1)];
  443. }
  444. aHPivHighs[0] = candPrc ;
  445. aHPivIdxs[0] = candIdx;
  446. nHPivs++;
  447. } else {
  448. // -- Bar and price info for candidate pivot
  449. candIdx = curBar - aLLVBars[curBar];
  450. candPrc = aLLV[curBar]; 
  451. if (
  452. lastLPL > candPrc AND
  453. candIdx > lastHPIdx AND
  454. candIdx < curBar) {
  455. // -- OK, we'll add this as a pivot...
  456. aLPivs[candIdx] = 1;
  457. // ...and then rearrange elements in the 
  458. // pivot information arrays
  459. for (j=0; j<nLPivs; j++) {
  460. aLPivLows[nLPivs-j] = aLPivLows[nLPivs-(j+1)];
  461. aLPivIdxs[nLPivs-j] = aLPivIdxs[nLPivs-(j+1)];
  462. }
  463. aLPivLows[0] = candPrc;
  464. aLPivIdxs[0] = candIdx;
  465. nLPivs++;
  466. }
  467. }
  468. // -- Dump inventory of high pivots for debugging
  469. /*
  470. for (k=0; k<nHPivs; k++) {
  471. _TRACE("High pivot no. " + k
  472. + " at barindex: " + aHPivIdxs[k] + ", " 
  473. + WriteVal(ValueWhen(BarIndex()==aHPivIdxs[k], 
  474. DateTime(), 1), formatDateTime)
  475. + ", " + aHPivHighs[k]);
  476. }
  477. */
  478. // -- OK, let's plot the pivots using arrows
  479. PlotShapes(
  480. IIf(aHPivs==1, shapeDownArrow, shapeNone), colorRed, 0,
  481. High, Offset=-15);
  482. PlotShapes(
  483. IIf(aLPivs==1, shapeUpArrow , shapeNone), colorGreen, 0, 
  484. Low, Offset=-15);
  485.