您现在的位置：程序化交易>> 期货公式>> 交易开拓者(TB)>> 开拓者知识>>正文内容

“MtParabolicSAR，跨周期抛物线转向ParabolicSAR函数”出炉　[开拓者 TB]

作者：开拓者 TB 来源：cxh99.com 发布时间：2014年05月29日 点击数： 　【收藏到本网的会员中心】
  • 咨询内容： 本帖最后由 扶老二 于 2014-5-11 19:34 编辑

    “MtParabolicSAR，跨周期抛物线转向ParabolicSAR函数”出炉

    有需要的帅哥美女拿去用吧，续贴到“追涨杀跌”的帖子里了：

    http://bbs.tb18.net/thread-15184-24-1.html

    有问题欢迎交流 QQ: 149561420
    1. //------------------------------------------------------------------------
    2. // MtParabolicSAR，跨周期抛物线转向ParabolicSAR函数
    3. // 返回 当前bar的“周期索引”，比如当前在1分钟周期里，折算成15分钟周期的话，从凌晨00:00分钟开始，第1根bar是1，第2根bar是2......第15根bar是15，第16根bar又变成1，......
    4. // 除了函数本身的返回值，还通过oParCl、oParOpen、oPosition、oTransition这四个引用参数把对应Bar的停损值、对应Bar的停损值下一根的停损值、对应Bar建议的持仓状态（1 - 多头，-1 - 空头）、对应Bar的状态是否发生反转（1 或 -1 为反转，0 为保持不变）
    5. // 版本 20140511_183500
    6. //------------------------------------------------------------------------

    8. Params
    9.     Numeric TimeFrame(1440);        //目标时间周期参数，参数说明参见MtBar
    10.     Numeric BarsBack(1);            //目标时间周期BAR偏移参数，说明见MtBar函数
    11.     Numeric AfStep(0.02);
    12.     Numeric AfLimit(0.2);
    13.     NumericRef oParClose;
    14.     NumericRef oParOpen;
    15.     NumericRef oPosition;
    16.     NumericRef oTransition;

    18. Vars
    19.     NumericSeries barCnt;
    20.     NumericSeries CurBar;
    21.     NumericSeries barCntSum;
    22.     NumericSeries HighHT;
    23.     NumericSeries LowHT;
    24.     Numeric CurTime;
    25.     Numeric PreTime;
    26.     bool condition(false);
    27.     Numeric n;
    28.     Numeric i;


    31.     NumericSeries Af(0);   
    32.     NumericSeries ParOpen(0);
    33.     NumericSeries ParClose(0);
    34.     NumericSeries Position(0);  
    35.     NumericSeries HHValue(0);
    36.     NumericSeries LLValue(0);
    37.     NumericSeries Transition(0);
    38.      
    39. Begin
    40.     if(TimeFrame == 40320) {                                        //月线
    41.         CurTime = Month;
    42.         PreTime = Month[1];
    43.     } else if(TimeFrame == 10080) {                                 //周线
    44.         CurTime = IntPart(DateDiff(19700105, TrueDate(0)) / 7);
    45.         PreTime = IntPart(DateDiff(19700105, TrueDate(1)) / 7);
    46.     } else {                                                        //其他时间周期
    47.         CurTime = IntPart((DateDiff(19700105, TrueDate(0)) * 1440 + Hour * 60 + Minute) / TimeFrame);
    48.         PreTime = IntPart((DateDiff(19700105, TrueDate(1)) * 1440 + Hour[1] * 60 + Minute[1]) / TimeFrame);
    49.     }

    51.     condition = CurTime != PreTime;

    53.     if(CurrentBar == 0) {                       //如果是第一根Bar, CurBar=0
    54.         barCnt = 0;
    55.         CurBar = 0;
    56.         HighHT = High[1];
    57.         LowHT = Low[1];
    58.         
    59.         Position = 1;
    60.         Transition = 1;
    61.         Af = AfStep;
    62.         HHValue = HighHT;
    63.         LLValue = LowHT;
    64.         ParClose = LLValue;
    65.         ParOpen = ParClose + Af * (HHValue - ParClose);
    66.         if(ParOpen > LowHT) {
    67.             ParOpen = LowHT;
    68.         }
    69.     } else {
    70.         if(condition) {                         //如果在目标周期下，属于另一根K线，则CurBar加1
    71.             barCnt = 1;
    72.             CurBar = CurBar[1] + 1;
    73.             HighHT = High[1];
    74.             LowHT = Low[1];
    75.             for n = 2 to TimeFrame {
    76.                 HighHT = Max(HighHT, High[n]);
    77.                 LowHT = Min(LowHT, Low[n]);
    78.             }
    79.         } else {                                //如果在目标周期下，属于同一根K线，则CurBar不变，但最高价和最低价要记录价格的变化，成交量要累加
    80.             barCnt = barCnt[1] + 1;
    81.             CurBar = CurBar[1];
    82.             HighHT = Max(HighHT[1], High);
    83.             LowHT = Min(LowHT[1], Low);
    84.         }
    85.         
    86.         HHValue = Max(HHValue[1], HighHT);
    87.         LLValue = Min(LLValue[1], LowHT);

    89.         if(CurBar == 0) {
    90.             Position = 1;
    91.             Transition = 1;
    92.             Af = AfStep;
    93.             ParClose = LLValue;
    94.             ParOpen = ParClose + Af * (HHValue - ParClose);
    95.             if(ParOpen > LowHT) {
    96.                 ParOpen = LowHT;
    97.             }
    98.         } else {        
    99.             if(condition) {                       //正好切换到目标周期的下一根k线
    100.                 Transition = 0;

    102.                 if(Position[TimeFrame] == 1) {
    103.                     if(LowHT <= ParOpen[TimeFrame]) {
    104.                         Position = -1;
    105.                         Transition = -1;              
    106.                         ParClose = HHValue;
    107.                         HHValue = HighHT;
    108.                         LLValue  = LowHT;
    109.             
    110.                         Af = AfStep;
    111.                         ParOpen = ParClose + Af * (LLValue - ParClose);
    112.                            
    113.                         if(ParOpen < HighHT) {
    114.                             ParOpen = HighHT;
    115.                         }
    116.                         
    117.                         if(ParOpen < HighHT[TimeFrame]) {
    118.                             ParOpen = HighHT[TimeFrame];
    119.                         }
    120.                     } else {
    121.                         Position = Position[TimeFrame];
    122.                         ParClose = ParOpen[TimeFrame];                    
    123.                         if(HHValue > HHValue[TimeFrame] && Af[TimeFrame] < AfLimit) {
    124.                             if(Af[TimeFrame] + AfStep > AfLimit) {
    125.                                 Af = AfLimit;
    126.                             } else {
    127.                                 Af = Af[TimeFrame] + AfStep;
    128.                             }               
    129.                         } else {
    130.                             Af = Af[TimeFrame];
    131.                         }   
    132.                         ParOpen = ParClose + Af * (HHValue - ParClose);               
    133.             
    134.                         if(ParOpen > LowHT) {
    135.                             ParOpen = LowHT;
    136.                         }
    137.                         
    138.                         if(ParOpen > LowHT[TimeFrame]) {
    139.                             ParOpen = LowHT[TimeFrame];
    140.                         }
    141.                     }
    142.                 } else {
    143.                     if(HighHT >= ParOpen[TimeFrame]) {
    144.                         Position = 1;
    145.                         Transition = 1;
    146.                         
    147.                         ParClose = LLValue;
    148.                         HHValue = HighHT;
    149.                         LLValue  = LowHT;
    150.                         
    151.                         Af = AfStep;
    152.                         ParOpen = ParClose + Af * (HHValue - ParClose);
    153.                         if(ParOpen > LowHT) {
    154.                             ParOpen = LowHT;
    155.                         }
    156.                         
    157.                         if(ParOpen > LowHT[TimeFrame]) {
    158.                             ParOpen = LowHT[TimeFrame];
    159.                         }
    160.                     } else {
    161.                         Position = Position[TimeFrame];
    162.                         ParClose = ParOpen[TimeFrame];
    163.                            
    164.                         if(LLValue < LLValue[TimeFrame] && Af[TimeFrame] < AfLimit) {
    165.                             if(Af[TimeFrame] + AfStep > AfLimit) {
    166.                                 Af = AfLimit;
    167.                             } else {
    168.                                 Af = Af[TimeFrame] + AfStep;
    169.                             }
    170.                         } else {
    171.                             Af = Af[TimeFrame];
    172.                         }
    173.                         ParOpen = ParClose + Af * (LLValue - ParClose);
    174.             
    175.                         if(ParOpen < HighHT) {
    176.                             ParOpen = HighHT;
    177.                         }
    178.                         
    179.                         if(ParOpen < HighHT[TimeFrame]) {
    180.                             ParOpen = HighHT[TimeFrame];
    181.                         }
    182.                     }
    183.                 }   
    184.             }
    185.         }
    186.     }
    187.    
    188.     //上面的程序，在每根小周期的K线上，记录了它所属的大时间周期下的开高低收等值的变化。
    189.     //接下来，要把在大的时间周期级别上，属于同一根K线的开高低收这些数据，记录在这一组小周期K线的最后一根上。
    190.     barCntSum = barCnt;

    192.     if(BarsBack == 0) {             //如果Bar偏移参数为0，则取每根小周期K线上保留的大时间周期截止到这根小周期K线为止的BAR数据
    193.         barCntSum = 0;
    194.     } else if(BarsBack == 1) {      //如果Bar偏移参数为1，则取大时间周期的上一根K线的BAr数据
    195.         barCntSum = barCnt;
    196.     } else {                        //如果BAR偏移参数为其他，则取大时间周期的指定偏移后的那根K线的BAR数据
    197.         for i = 2 to BarsBack {
    198.             barCntSum = barCntSum + barCnt[barCntSum];
    199.         }
    200.     }

    202.     //最后将相应的K线数据作为引用参数返回
    203.     oParClose = ParClose[barCntSum];
    204.     oParOpen = ParOpen[barCntSum];
    205.     oPosition = Position[barCntSum];
    206.     oTransition = Transition[barCntSum];
    207.    
    208.     Return true;
    209. End

     

  • TB技术人员： 群主我用rb的日线跟此函数timeframe1440进行了对比发现不匹配

     

  • TB客服：
    duck_arrow 发表于 2014-5-13 15:12
    群主我用rb的日线跟此函数timeframe1440进行了对比发现不匹配

    跟tb自带的ParabolicSAR函数比对发现不匹配。其实主要是tb自带的ParabolicSAR函数代码里High和Low都用的当前k线的数据导致，这是有问题的，当前k线还没运行结束之前，High和Low都是未来的属性，所以直接使用它，会导致实盘时候信号闪烁和使用了未来属性，我修复了一下tb自带的ParabolicSAR，用High[1]和Low[1]来取代High和Low，取名ParabolicSAR_ximen，请用以下代码新建用户函数，函数名叫ParabolicSAR_ximen，然后在不需要跨周期的时候，建议用ParabolicSAR_ximen来替换ParabolicSAR：
    1. //------------------------------------------------------------------------
    2. // 西门 ParabolicSAR_ximen
    3. // 描述 求抛物线转向，修正系统默认用当前bar会导致闪烁的问题，采用[1]来做判断依据，比系统默认函数更精确
    4. // 返回 True 或 false。除了函数本身的返回值，还通过oParCl、oParOpen、oPosition、oTransition这四个引用参数把对应Bar的停损值、对应Bar的停损值下一根的停损值、对应Bar建议的持仓状态（1 - 多头，-1 - 空头）、对应Bar的状态是否发生反转（1 或 -1 为反转，0 为保持不变）
    5. // 版本 20140511
    6. //------------------------------------------------------------------------


    9. Params
    10.     Numeric AfStep(0.02);
    11.     Numeric AfLimit(0.2);
    12.     NumericRef oParClose;
    13.     NumericRef oParOpen;
    14.     NumericRef oPosition;
    15.     NumericRef oTransition;
    16.    
    17. Vars
    18.     NumericSeries HighHT;
    19.     NumericSeries LowHT;

    21.     NumericSeries Af(0);   
    22.     NumericSeries ParOpen(0);
    23.     NumericSeries ParClose(0);
    24.     NumericSeries Position(0);  
    25.     NumericSeries HHValue(0);
    26.     NumericSeries LLValue(0);
    27.     NumericSeries Transition(0);

    29. Begin               
    30.     if(CurrentBar == 0) {
    31.                 HighHT = High;
    32.                 LowHT = Low;
    33.                
    34.         Position = 1;
    35.         Transition = 1;
    36.         Af = AfStep;
    37.         HHValue = HighHT;
    38.         LLValue = LowHT;
    39.         ParClose = LLValue;
    40.         ParOpen = ParClose + Af * ( HHValue - ParClose);
    41.         if(ParOpen > LowHT) {
    42.             ParOpen = LowHT;
    43.         }
    44.     } else {
    45.                 HighHT = High[1];
    46.                 LowHT = Low[1];
    47.                
    48.                 HHValue = Max(HHValue[1], HighHT);
    49.                 LLValue = Min(LLValue[1], LowHT);

    51.         Transition = 0;

    53.         if(Position[1] == 1) {
    54.             if(LowHT <= ParOpen[1]) {
    55.                 Position = -1;
    56.                 Transition = -1;              
    57.                 ParClose = HHValue;
    58.                 HHValue = HighHT;
    59.                 LLValue  = LowHT;
    60.    
    61.                 Af = AfStep;
    62.                 ParOpen = ParClose + Af * (LLValue - ParClose);
    63.                     
    64.                 if(ParOpen < HighHT) {
    65.                     ParOpen = HighHT;
    66.                 }
    67.                
    68.                 if(ParOpen < HighHT[1]) {
    69.                     ParOpen = HighHT[1];
    70.                 }
    71.             } else {
    72.                 Position = Position[1];
    73.                 ParClose = ParOpen[1];                    
    74.                 if(HHValue > HHValue[1] && Af[1] < AfLimit) {
    75.                     if(Af[1] + AfStep > AfLimit) {
    76.                         Af = AfLimit;
    77.                     } else {
    78.                         Af = Af[1] + AfStep;
    79.                     }               
    80.                 } else {
    81.                     Af = Af[1];
    82.                 }   
    83.                 ParOpen = ParClose + Af * (HHValue - ParClose);               
    84.    
    85.                 if(ParOpen > LowHT) {
    86.                     ParOpen = LowHT;
    87.                 }
    88.                
    89.                 if(ParOpen > LowHT[1]) {
    90.                     ParOpen = LowHT[1];
    91.                 }
    92.             }
    93.         } else {
    94.             if(HighHT >= ParOpen[1]) {
    95.                 Position = 1;
    96.                 Transition = 1;
    97.                
    98.                 ParClose = LLValue;
    99.                 HHValue = HighHT;
    100.                 LLValue  = LowHT;
    101.                
    102.                 Af = AfStep;
    103.                 ParOpen = ParClose + Af * (HHValue - ParClose);
    104.                 if(ParOpen > LowHT) {
    105.                     ParOpen = LowHT;
    106.                 }
    107.                
    108.                 if(ParOpen > LowHT[1]) {
    109.                     ParOpen = LowHT[1];
    110.                 }
    111.             } else {
    112.                 Position = Position[1];
    113.                 ParClose = ParOpen[1];
    114.                     
    115.                 if(LLValue < LLValue[1] && Af[1] < AfLimit) {
    116.                     if(Af[1] + AfStep > AfLimit) {
    117.                         Af = AfLimit;
    118.                     } else {
    119.                         Af = Af[1] + AfStep;
    120.                     }
    121.                 } else {
    122.                     Af = Af[1];
    123.                 }
    124.                 ParOpen = ParClose + Af * (LLValue - ParClose);
    125.    
    126.                 if(ParOpen < HighHT) {
    127.                     ParOpen = HighHT;
    128.                 }
    129.                
    130.                 if(ParOpen < HighHT[1]) {
    131.                     ParOpen = HighHT[1];
    132.                 }
    133.             }
    134.         }  
    135.     }   
    136.    
    137.     oParClose = ParClose;
    138.     oParOpen = ParOpen;
    139.     oPosition = Position;
    140.     oTransition = Transition;

    142.     Return True;
    143. End
    复制代码下面是不跨周期的ParabolicSAR_ximen调用的例子：
    1. Params

    3. Vars       
    4.         Numeric oParCl;
    5.         Numeric oParOp;
    6.         Numeric oPosition;
    7.         Numeric oTransition;
    8.        
    9. begin
    10.         ParabolicSAR_ximen(0.02, 0.2, oParCl, oParOp, oPosition, oTransition);
    11.          
    12.         Commentary("oParCl:" + Text(oParCl));
    13.         Commentary("oParOp:" + Text(oParOp));
    14.         Commentary("oPosition:" + Text(oPosition));
    15.         Commentary("oTransition:" + Text(oTransition));
    16. End        
    复制代码

 

有思路，想编写各种指标公式，程序化交易模型，选股公式，预警公式的朋友

可联系技术人员 QQ: 1145508240  点击这里给我发消息进行 有偿 编写！（不贵！点击查看价格！）


【字体：小 大】【打印文章】【查看评论】

相关文章

    没有相关内容

栏目导航

 本月热门排行

 用户常看内容