osato.1990
24 Jan 2019, 15:16

RE:

Panagiotis Charalampous said:

Hi oons,

Thanks for posting in our forum. What do you expect the cBot to do and what does it do instead?

Best Regards,

Panagiotis

Thank you for the immediate reply.

In the case BUY at a timing when a short-term MA crosses over a long-term MA, even if a stop loss or a take profit is filled, as long as short-term MA is staying above long-term MA, BUY again .

Once the position has been closed, I would like to set the next position to be only in the opposite direction.

For example ...
The trade after the longposition has been closed should only take the shortposition.
The trade after the shortposition has been closed is to ensure that only the longposition can be held.

※ In the case of the MA crossover system,

var currentSlowMa = slowMa.Result.Last (0);
var currentFastMa = fastMa.Result.Last (0);
var previousSlowMa = slowMa.Result.Last (1);
var previousFastMa = fastMa.Result.Last (1);

if (currentSlowMa <currentFastMa && previousSlowMa> previousFastMa && longPosition == null)

By describing as above,I think that it will be possible to prevent the previous position and the new position from being in the same direction.

However, since I want to apply it to others, I would like to know how to set the next position to be only in the opposite direction when the position is closed once.

I'm sorry for the poor explanation, but I'm happy if I get an answer.

osato.1990
23 Jan 2019, 15:36

RE:

Panagiotis Charalampous said:

Hi jelle2500,

You can use a condition like below

            if (Positions.Count(x => x.TradeType == TradeType.Buy) == 0)
            {
                // Execute Buy Trade
            }

?Let me know if this helps you

 

Best Regards,

Panagiotis

Thank you for your help.
Well I am suffering from the same problem.

if (Positions.Count (x => x.TradeType == TradeType.Buy) == 0)

Where should the above code be inserted?

I wrote the following program but it does not work properly.

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class crossover : Robot
    {
        [Parameter("MA Type")]
        public MovingAverageType MAType { get; set; }

        [Parameter()]
        public DataSeries SourceSeries { get; set; }

        [Parameter("Slow Periods", DefaultValue = 20)]
        public int SlowPeriods { get; set; }

        [Parameter("Fast Periods", DefaultValue = 5)]
        public int FastPeriods { get; set; }

        [Parameter("Quantity (Lots)", DefaultValue = 1, MinValue = 0.01, Step = 0.01)]
        public double Quantity { get; set; }

        [Parameter("Stop Loss (pips)", DefaultValue = 50, MinValue = 1)]
        public int StopLossInPips { get; set; }

        [Parameter("Take Profit (pips)", DefaultValue = 4000, MinValue = 1)]
        public int TakeProfitInPips { get; set; }

        [Parameter("Position Label", DefaultValue = "My Label")]
        public string MyLabel { get; set; }


        private MovingAverage slowMa;
        private MovingAverage fastMa;
        private const string label = "Sample Trend cBot";


        protected override void OnStart()
        {
            fastMa = Indicators.MovingAverage(SourceSeries, FastPeriods, MAType);
            slowMa = Indicators.MovingAverage(SourceSeries, SlowPeriods, MAType);
        }

        protected override void OnTick()
        {
            var longPosition = Positions.Find(label, Symbol, TradeType.Buy);
            var shortPosition = Positions.Find(label, Symbol, TradeType.Sell);

            var currentSlowMa = slowMa.Result.Last(1);
            var currentFastMa = fastMa.Result.Last(1);
            var previousSlowMa = slowMa.Result.Last(2);
            var previousFastMa = fastMa.Result.Last(2);



            if (currentSlowMa < currentFastMa && longPosition == null && Positions.Count(x => x.TradeType == TradeType.Buy) == 0)
            {
                if (shortPosition != null)
                    ClosePosition(shortPosition);

                ExecuteMarketOrder(TradeType.Buy, Symbol, VolumeInUnits, label, StopLossInPips, TakeProfitInPips);
            }



            else if (currentSlowMa > currentFastMa && shortPosition == null && Positions.Count(x => x.TradeType == TradeType.Sell) == 0)
            {
                if (longPosition != null)
                    ClosePosition(longPosition);
                ExecuteMarketOrder(TradeType.Sell, Symbol, VolumeInUnits, label, StopLossInPips, TakeProfitInPips);
            }
        }

        private long VolumeInUnits
        {
            get { return Symbol.QuantityToVolume(Quantity); }
        }
    }
}

I am sorry that I am a beginner so it will be helpful if you let me know・・・