Exemple #1
0
 protected override void OnStart()
 {
     Print("START GyBolliBanBreak: {0}", Server.Time.ToLocalTime());
     BolliBan1  = Indicators.BollingerBands(SourceBB, PeriodBB, DeviateBB1, MaTypeBB);
     BolliBan2  = Indicators.BollingerBands(SourceBB, PeriodBB, DeviateBB2, MaTypeBB);
     SignalMA   = Indicators.SimpleMovingAverage(SourceSignalMA, PeriodSignalMA);
     FilterADX  = Indicators.DirectionalMovementSystem(PeriodADX);
     curstate   = States.Initial;
     longstate  = HasLong.Initial;
     shortstate = HasShort.Initial;
 }
        public override int GetHashCode()
        {
            var hashCode = 1745518476;

            hashCode = hashCode * -1521134295 + EqualityComparer <CommandStructure> .Default.GetHashCode(Parent);

            hashCode = hashCode * -1521134295 + EqualityComparer <string[]> .Default.GetHashCode(Names);

            hashCode = hashCode * -1521134295 + HasShort.GetHashCode();
            hashCode = hashCode * -1521134295 + IsExclusive.GetHashCode();
            hashCode = hashCode * -1521134295 + EqualityComparer <string[]> .Default.GetHashCode(Others);

            return(hashCode);
        }
Exemple #3
0
        private void PositionsOnClosed(PositionClosedEventArgs args)
        {
            var pos  = args.Position;
            var reas = args.Reason;

            Print("Position closed with {0} profit.    Reason : {1}", pos.GrossProfit, reas);
            // ポジションのステータスリセット
            if (longstate == HasLong.Closed)
            {
                longstate = HasLong.Initial;
            }
            if (shortstate == HasShort.Closed)
            {
                shortstate = HasShort.Initial;
            }
        }
Exemple #4
0
        protected override void OnBar()
        {
            var top1    = BolliBan1.Top.Last(0);
            var bottom1 = BolliBan1.Bottom.Last(0);
            var main    = BolliBan1.Main.LastValue;
            var top2    = BolliBan2.Top.Last(0);
            var bottom2 = BolliBan2.Bottom.Last(0);
            var avr0    = SignalMA.Result.Last(0);
            var avr1    = SignalMA.Result.Last(1);

            diplus  = FilterADX.DIPlus.LastValue;
            diminus = FilterADX.DIMinus.LastValue;
            diadx   = FilterADX.ADX.LastValue;

            // cBot AUTO STOP
            if (CbotAutoStop == true)
            {
                if (CbotTimer > CbotTimeOut)
                {
                    Print("cBot AUTO STOP [ cBot Timer : {0} / {1} ]", CbotTimer, CbotTimeOut);
                    Close(TradeType.Buy);
                    Close(TradeType.Sell);
                    Stop();
                }
                else
                {
                    CbotTimer = CbotTimer + 1;
                }
            }

            // ステータス変更後カウンタ
            StateCount = StateCount + 1;

            // ステータス変化とトレード
            switch (curstate)
            {
            case States.Initial:

                if (ActSell == true && avr1 >= bottom2 && avr0 < bottom2)
                {
                    Print("{0}  2σボトム下抜け         STATE: {1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (CheckOpen())
                    {
                        curstate = States.Bottom2_Below;
                    }
                    StateCount = 0;
                }
                else if (ActBuy == true && avr1 <= top2 && avr0 > top2)
                {
                    Print("{0}  2σトップ上抜け         STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (CheckOpen())
                    {
                        curstate = States.Top2_Above;
                    }
                    StateCount = 0;
                }
                break;

            case States.Top2_Above:

                if (avr0 < top2)
                {
                    Print("{0}  2σトップ下抜け          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Top2_Below;
                    StateCount = 0;
                }
                break;

            case States.Bottom2_Below:

                if (avr0 > bottom2)
                {
                    Print("{0}  2σボトム上抜け          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Bottom2_Above;
                    StateCount = 0;
                }
                break;

            case States.Top2_Below:

                if (avr0 < top1)
                {
                    Print("{0}  トップ1σ下抜け          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (longstate == HasLong.ToClose)
                    {
                        longstate = HasLong.Closed;     // Closeの前に変更
                        if (CloseTSL == true)
                        {
                            SetTSL(TradeType.Buy);      //TrailingSLで利を伸ばす
                            curstate = States.Top1_Below;

                            longstate = HasLong.Initial;
                        }
                        else
                        {
                            Close(TradeType.Buy);       //CLOSE
                            curstate = States.Initial;

                            longstate = HasLong.Initial;
                        }
                    }
                    else
                    {
                        curstate = States.Top1_Below;
                    }
                    StateCount = 0;
                }
                else if (avr0 > top2)
                {
                    Print("{0}  トップ2σ再度上抜け      STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Top2_Above;    //ステータス復帰
                    StateCount = 0;
                }
                break;

            case States.Bottom2_Above:

                if (avr0 > bottom1)
                {
                    Print("{0}  ボトム1σ上抜け          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (shortstate == HasShort.ToClose)
                    {
                        shortstate = HasShort.Closed;     // Closeの前に変更
                        if (CloseTSL == true)
                        {
                            SetTSL(TradeType.Sell);      //TrailingSLで利を伸ばす
                            curstate = States.Bottom1_Above;

                            shortstate = HasShort.Initial;
                        }
                        else
                        {
                            Close(TradeType.Sell);       //CLOSE
                            curstate = States.Initial;

                            shortstate = HasShort.Initial;
                        }
                    }
                    else
                    {
                        curstate = States.Bottom1_Above;
                    }
                    StateCount = 0;
                }
                else if (avr0 < bottom2)
                {
                    Print("{0}  ボトム2σ再度下抜け      STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Bottom2_Below;    //ステータス復帰
                    StateCount = 0;
                }
                break;

            case States.Top1_Below:

                if (avr0 <= main)
                {
                    Print("{0}  トップ1σ→MAIN         STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (longstate != HasLong.Initial)
                    {
                        longstate = HasLong.Closed;
                        Close(TradeType.Buy);       //CLOSE

                        longstate = HasLong.Initial;
                    }
                    curstate   = States.Initial;
                    StateCount = 0;
                }
                else if (avr0 > top1)
                {      // ロング:BandWalk
                    Print("{0}  トップ1σ再度上抜け     STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate = States.Top1_Above;
                    if (longstate == HasLong.Initial)
                    {
                        Open(TradeType.Buy);      //ロング  エントリー条件厳格化(1σ戻り待ち)
                        longstate = HasLong.Open;
                    }
                    StateCount = 0;
                }
                break;

            case States.Bottom1_Above:

                if (avr0 >= main)
                {
                    Print("{0}  ボトム1σ→MAIN          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (shortstate != HasShort.Initial)
                    {
                        shortstate = HasShort.Closed;
                        Close(TradeType.Sell);     // CLOSE

                        shortstate = HasShort.Initial;
                    }
                    curstate   = States.Initial;
                    StateCount = 0;
                }
                else if (avr0 < bottom1)
                {      // ショート:BandWalk
                    Print("{0}  ボトム1σ再度下抜け      STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate = States.Bottom1_Below;
                    if (shortstate == HasShort.Initial)
                    {
                        Open(TradeType.Sell);      //ショート  エントリー条件厳格化(1σ戻り待ち)
                        shortstate = HasShort.Open;
                    }
                    StateCount = 0;
                }
                break;

            case States.Top1_Above:

                if (avr0 <= main)
                {      // ロング:CLOSE
                    Print("{0}  トップ1σ→MAIN          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (longstate != HasLong.Initial)
                    {
                        longstate = HasLong.Closed;
                        Close(TradeType.Buy);       //CLOSE

                        longstate = HasLong.Initial;
                    }
                    curstate   = States.Initial;
                    StateCount = 0;
                }
                else if (avr0 > top2)
                {      // ロング:BandWalk
                    Print("{0}  トップ2σ再度上抜け      STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Top2_Above;
                    StateCount = 0;
                    if (longstate == HasLong.Open)
                    {
                        longstate = HasLong.ToClose;      // 利食いに向けたステータス。以降は1σタッチでもCLOSE
                    }
                }
                break;

            case States.Bottom1_Below:

                if (avr0 >= main)
                {      // ショート:CLOSE
                    Print("{0}  ボトム1σ→MAIN          STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    if (shortstate != HasShort.Initial)
                    {
                        shortstate = HasShort.Closed;
                        Close(TradeType.Sell);     // CLOSE

                        shortstate = HasShort.Initial;
                    }
                    curstate   = States.Initial;
                    StateCount = 0;
                }
                else if (avr0 < bottom2)
                {      // ショート:BandWalk
                    Print("{0}  ボトム2σ再度下抜け      STATE:{1}, StateCount: {2}, DI-: {3}, DI+: {4}, ADX: {5}", avr0, curstate, StateCount, diminus, diplus, diadx);
                    curstate   = States.Bottom2_Below;
                    StateCount = 0;
                    if (shortstate == HasShort.Open)
                    {
                        shortstate = HasShort.ToClose;      // 利食いに向けたステータス。以降は1σタッチでもCLOSE
                    }
                }
                break;
            }
        }