Exemple #1
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            dealprice   = new double[2];
            dealtime    = new DateTime[2];
            dealcounter = 0;
            this.inputs = inputs;
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            min_node     = parser.GetInt("MinValue");
            gap_position = parser.GetInt("GapPosition");
            if (gap_position < 0 || gap_position > Model.Project.Outputs.Count)
            {
                return(false);
            }
            Fut = parser.GetInt("Future");
            if (Fut < 0 || Fut >= inputs.Count)
            {
                return(false);
            }
            Value     = 0;
            type      = 0;
            next_peak = 0;
            max_gap   = 0;
            min_gap   = 0;
            ready     = false;
            peak_time = new DateTime();
            string name = parser.GetString("Name");

            file_name_profit = Path.Combine(logPath, name + "_profit_log.txt");
            file_name_lose   = Path.Combine(logPath, name + "_lose_log.txt");
            return(true);
        }
Exemple #2
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            call = parser.GetInt("Call");
            put  = parser.GetInt("Put");
            if (call < 0 || call >= inputs.Count)
            {
                return(false);
            }
            if (put < 0 || put >= inputs.Count)
            {
                return(false);
            }
            strike   = parser.GetDouble("Strike");
            type     = parser.GetInt("Type");
            inp_name = parser.GetString("input_name");
            //inp_name_2 = parser.GetString("input_name_2");

            /* if(inp_name_2 == inp_name)
             * {
             *   inp_name_2 += "_n";
             * }*/
            this.inputs = inputs;
            SyntheticFutureInput.AddKey(inp_name);
            //SyntheticFutureInput.AddKey(inp_name_2);
            return(true);
        }
Exemple #3
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            if (Models.InputItemInteractivBrokerModel.IB == null)
            {
                return(false);
            }
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            simtradeid = parser.GetInt("SimTrade_ID");
            if (simtradeid < 0 || simtradeid > Model.Project.Outputs.Count)
            {
                return(false);
            }
            tradeId = parser.GetInt("TradeID");
            tradeTerminal.FirstBroker = new ModelsAT.BrokerMT(tradeId);
            tradeTerminal.FirstBroker.setBrokerParam("Name", parser.GetString("MT_name"));
            tradeTerminal.FirstBroker.setOrderParam("MKT");
            tradeTerminal.SecondBroker = new ModelsAT.BrokerIBOptionPair(tradeId, Models.InputItemInteractivBrokerModel.IB);
            tradeTerminal.SecondBroker.setBrokerParam("Put", parser.GetString("IB_Put_name"));
            tradeTerminal.SecondBroker.setBrokerParam("Call", parser.GetString("IB_Call_name"));
            tradeTerminal.SecondBroker.setBrokerParam("Volume", parser.GetString("Volume_IB"));
            tradeTerminal.SecondBroker.setBrokerParam("LimitPrice", parser.GetString("LMT_Price_IB"));
            tradeTerminal.SecondBroker.setOrderParam(parser.GetString("OrderType_IB"));
            SimTrade = Model.Project.Proccesors[simtradeid];
            SimTrade.ProcessorAction += EventHandler;
            if (parser.GetInt("IsReal") == 1)
            {
                tradeTerminal.FirstBroker.isReal  = true;
                tradeTerminal.SecondBroker.isReal = true;
            }
            Model.OutputsInitializeEnd += InitializeHandler;
            return(true);
        }
Exemple #4
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            requst_put  = new Queue <SomeStruct>();
            requst_call = new Queue <SomeStruct>();
            this.inputs = inputs;
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            Put = parser.GetInt("Put");
            if (Put < 0 || Put >= inputs.Count)
            {
                return(false);
            }
            Call = parser.GetInt("Call");
            if (Call < 0 || Call >= inputs.Count)
            {
                return(false);
            }
            name = parser.GetString("Name");
            SetServer();
            return(true);
        }
Exemple #5
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            dealprice   = new double[2];
            dealtime    = new DateTime[2];
            dealcounter = 0;
            this.inputs = inputs;
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            min_node     = parser.GetInt("MinValue");
            gap_position = parser.GetInt("GapPosition");
            if (gap_position < 0 || gap_position > Model.Project.Outputs.Count)
            {
                return(false);
            }
            Fut = parser.GetInt("Future");
            if (Fut < 0 || Fut >= inputs.Count)
            {
                return(false);
            }
            string name = parser.GetString("Name");

            file_name_profit     = Path.Combine(logPath, name + "_profit_log.txt");
            file_name_lose       = Path.Combine(logPath, name + "_lose_log.txt");
            prev_peak            = 0;
            next_value_to_change = 0;
            dealtype             = DealType.NONE;
            global_profit        = 0;
            global_lose          = 0;
            Value = 0;
//Gap = Model.Project.Proccesors[gap_position];
            //Gap.ProcessorAction += GapWorker;
            IsNewValue = false;
            return(true);
            //throw new NotImplementedException();
        }
Exemple #6
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            ClosePositionStopTrade += Stop;
            if (Models.InputItemInteractivBrokerModel.IB == null)
            {
                return(false);
            }
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            zigzagid      = parser.GetInt("ZigZag_ID");
            zigzagidsmall = parser.GetInt("ZigZagSmall_ID");
            if (zigzagid < 0 || zigzagid > Model.Project.Outputs.Count)
            {
                return(false);
            }
            if (zigzagidsmall < 0 || zigzagidsmall > Model.Project.Outputs.Count)
            {
                return(false);
            }
            gappos = parser.GetInt("Gap");
            if (gappos < 0 || gappos > Model.Project.Outputs.Count)
            {
                return(false);
            }
            //Gap = Model.Project.Proccesors[gappos];
            //Gap.ProcessorAction += PositionHandler;
            //ZigZag = Model.Project.Proccesors[zigzagid];
            //ZigZag.ProcessorAction += EventHandler;
            MinValueSmall = new List <ProbaStruct>();
            MaxValueSmall = new List <ProbaStruct>();
            MinValueBig   = new List <ProbaStruct>();
            MaxValueBig   = new List <ProbaStruct>();
            PositionShort = new Position();
            PositionLong  = new Position();
            name          = parser.GetString("Name");
            ratio         = parser.GetDouble("Ratio");
            tradeTerminal = new ModelsAT.BrokerMT(parser.GetInt("tradeTerminalID"));
            tradeTerminal.setBrokerParam("Name", parser.GetString("ServerName"));
            tradeTerminal.SetServer();
            Size = parser.GetInt("Size");
            if (parser.GetInt("IsReal") == 1)
            {
                tradeTerminal.isReal = true;
            }
            if (parser.GetInt("Logg") == 1)
            {
                LoggNeeded = true;
            }
            else
            {
                LoggNeeded = false;
            }
            //if (divergence > size || divergence == 0) return false;
            openlongcloseshort          = false;
            openshortcloselong          = false;
            longlock                    = false;
            shortlock                   = false;
            profit_to_close             = parser.GetInt("TakeProfit") * Math.Pow(10, -Model.Project.Outputs[gappos].Digits);
            lose_to_close               = parser.GetInt("StopLoss") * Math.Pow(10, -Model.Project.Outputs[gappos].Digits);
            convergenceshort            = false;
            convergencelong             = false;
            divergenceshort             = false;
            divergencelong              = false;
            lastvalue                   = LastZigZagValue.NONE;
            all_profit                  = 0;
            openpos                     = OpenPosition.NONE;
            ConvergenMin                = new ProbaStruct();
            ConvergenMax                = new ProbaStruct();
            Model.OutputsInitializeEnd += InitializeHandler;
            Model.LoadSimulation       += LoadSec;
            return(true);
        }
Exemple #7
0
        public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger)
        {
            ClosePositionStopTrade += Stop;
            if (Models.InputItemInteractivBrokerModel.IB == null)
            {
                return(false);
            }
            this.logger = logger;
            ParametersParser parser = CreateParser(parameters);

            zigzagid_1 = parser.GetInt("ZigZag_ID1");
            if (zigzagid_1 < 0 || zigzagid_1 > Model.Project.Outputs.Count)
            {
                return(false);
            }
            zigzagid_2 = parser.GetInt("ZigZag_ID2");
            if (zigzagid_2 < 0 || zigzagid_2 > Model.Project.Outputs.Count)
            {
                return(false);
            }
            zigzagid_2_2 = parser.GetInt("ZigZag_ID2_2");
            gappos       = parser.GetInt("Gap");
            if (gappos < 0 || gappos > Model.Project.Outputs.Count)
            {
                return(false);
            }
            int t_t = parser.GetInt("type");

            switch (t_t)
            {
            case (0):
                trader_type = TradeType.STANDART;
                break;

            case (1):
                trader_type = TradeType.IN_OUT;
                break;

            default:
                trader_type = TradeType.ONE_IN_TWO_OUT;
                break;
            }
            //Gap = Model.Project.Proccesors[gappos];
            //Gap.ProcessorAction += PositionHandler;
            //ZigZag = Model.Project.Proccesors[zigzagid];
            //ZigZag.ProcessorAction += EventHandler;
            divergenceOpen    = parser.GetInt("DivergenceOpen");
            divergenceClose   = parser.GetInt("DivergenceClose");
            convergen_counter = parser.GetInt("Convergence");
            if (divergenceOpen < 0 || divergenceClose < 0 || convergen_counter < 0)
            {
                return(false);
            }
            MinValueOpen_1    = new List <ProbaStruct>();
            MaxValueOpen_1    = new List <ProbaStruct>();
            MinValueClose_1   = new List <ProbaStruct>();
            MaxValueClose_1   = new List <ProbaStruct>();
            MinValueOpen_2    = new List <ProbaStruct>();
            MaxValueOpen_2    = new List <ProbaStruct>();
            MinValueClose_2   = new List <ProbaStruct>();
            MaxValueClose_2   = new List <ProbaStruct>();
            MinValueOpen_2_2  = new List <ProbaStruct>();
            MaxValueOpen_2_2  = new List <ProbaStruct>();
            MinValueClose_2_2 = new List <ProbaStruct>();
            MaxValueClose_2_2 = new List <ProbaStruct>();
            PositionShort     = new List <Position>();
            PositionLong      = new List <Position>();
            name            = parser.GetString("Name");
            ratio           = parser.GetDouble("Ratio");
            profit_to_close = parser.GetInt("TakeProfit") * Math.Pow(10, -Model.Project.Outputs[gappos].Digits);
            lose_to_close   = parser.GetInt("StopLoss") * Math.Pow(10, -Model.Project.Outputs[gappos].Digits);
            ratio_exp       = parser.GetDouble("Ratio_O");
            tradeTerminal   = new ModelsAT.BrokerMT(parser.GetInt("tradeTerminalID"));
            tradeTerminal.setBrokerParam("Name", parser.GetString("ServerName"));
            tradeTerminal.SetServer();
            if (parser.GetInt("IsReal") == 1)
            {
                tradeTerminal.isReal = true;
            }
            else
            {
                tradeTerminal.isReal = false;
            }
            if (parser.GetInt("Logg") == 1)
            {
                LoggNeeded = true;
            }
            else
            {
                LoggNeeded = false;
            }
            if (parser.GetInt("Expand") == 1)
            {
                can_expand = true;
            }
            else
            {
                can_expand = false;
            }
            divergence_max_open   = 0;
            divergence_min_open   = 0;
            divergence_max_close  = 0;
            divergence_min_close  = 0;
            openlong              = false;
            openshort             = false;
            closelong             = false;
            expand_position_short = false;
            expand_position_long  = false;
            closeshort            = false;
            lastvalue             = LastZigZagValue.NONE;
            all_profit            = 0;
            openpos       = OpenPosition.NONE;
            convergen_min = 0;
            convergen_max = 0;
            ConvergenMin  = new ProbaStruct();
            ConvergenMax  = new ProbaStruct();
            last_pos      = new LastPosition();
            Model.OutputsInitializeEnd += InitializeHandler;
            Model.LoadSimulation       += LoadSec;
            return(true);
        }