private void GetBasicInfo(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo) { IOIDSettingDTO SelectedSetting; IList <Action <IList <string>, string, object> > MappingHandlers; //Get setting of interest SelectedSetting = OIDSettings["DeviceBasicInfo"]; //Define handle collection in order MappingHandlers = new List <Action <IList <string>, string, object> >(); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).Description = y; }); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).OIDobjectID = y; }); MappingHandlers.Add(null); MappingHandlers.Add(null); MappingHandlers.Add((x, y, z) => { EnumDeviceType dvt; IDeviceTopologyInfoDTO Data = (IDeviceTopologyInfoDTO)z; Data.DeviceName = y; Data.DeviceType = Enum.TryParse <EnumDeviceType>(Regex.Match(y, @"^.*?(?=[0-9])").ToString(), out dvt) ? dvt : EnumDeviceType.Unknown; }); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).Location = y; }); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).OSIImplementedLayers = (EnumOSILayers)Enum.Parse(typeof(EnumOSILayers), y); }); //Add network known data TopologyInfo.DeviceIPAndMask = $"{Device.TargetIP}/{Device.NetworkMask}"; if (RegardingObject.ARPTable.Any(x => x.Value == $"{Device.TargetIP}")) { TopologyInfo.DeviceMAC = RegardingObject.ARPTable.Where(x => x.Value == $"{Device.TargetIP}").First().Key; } //Collect data mapping with handlers StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers); }
public IDictionary <string, IDictionary <DateTime, decimal> > GetCurrentRates(IList <string> rates) { IDictionary <string, IDictionary <DateTime, decimal> > historyData = new Dictionary <string, IDictionary <DateTime, decimal> >(); try { IList <RateRecord> rts = RateProvider.Instance.GetRates(); foreach (string rate in rates) { var hd = new Dictionary <DateTime, decimal>(); var record = rts.Where(item => item.Name == rate).FirstOrDefault(); if (record == null) { continue; } StrategyHelper.CloseCandle(_candles, record, CANDLES_INTERVAL_MINUTES); hd.Add(record.UpdateTime, record.Value); historyData.Add(rate, hd); } } catch (Exception ex) { SendMessageEvent(ex.Message); } return(historyData); }
public void DeleteSytrategyAssemblyFromSavedDirectoryTest() { bool deleted = true; //var folderName = // StrategyHelper.GetStrategyFileName( // @"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Debug\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll"); var folderName = "TradeHub.StrategyEngine.Testing.SimpleStrategy"; StrategyHelper.RemoveAssembly(folderName); var allStrategyNames = StrategyHelper.GetAllStrategiesName(); foreach (string strategyName in allStrategyNames) { if (strategyName.Equals("TradeHub.StrategyEngine.Testing.SimpleStrategy")) { deleted = false; break; } } Assert.IsTrue(deleted); }
/// <summary> /// Finds parameters to be used for optimization for the given Strategy and displays on UI /// </summary> private void OptimizationParameterDetails() { // Clear existing data OptimizationParameters.Clear(); // Contains custom defined attributes in the given assembly Dictionary <int, Tuple <string, Type> > customAttributes = null; // Get Custom Attributes if (_selectedStrategy.StrategyType != null) { // Get custom attributes from the given assembly customAttributes = StrategyHelper.GetCustomAttributes(_selectedStrategy.StrategyType); foreach (KeyValuePair <int, Tuple <string, Type> > keyValuePair in customAttributes) { var parameter = new OptimizationParameterDetail(); parameter.Index = keyValuePair.Key; parameter.Description = keyValuePair.Value.Item1; parameter.ParameterType = keyValuePair.Value.Item2; // Add to observable collection to display on UI OptimizationParameters.Add(parameter); } } }
public void GetStrategyPathTest() { _dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1"); string path = StrategyHelper.GetStrategyPath("Strategy1"); Assert.AreEqual(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1\\Strategy1.dll", path); }
/// <summary> /// Argument Constructor /// </summary> /// <param name="strategyType"></param> /// <param name="ctorArguments"></param> public TestStrategyExecutor(Type strategyType, object[] ctorArguments) { // Initialize parameters //TestStrategyInitializeParameters(strategyType,ctorArguments); _manualReset = new ManualResetEvent(false); _asyncClassLogger = new AsyncClassLogger("TestStrategyExecutor"); // Save Strategy Type _strategyType = strategyType; //Save Arguments _ctorArguments = ctorArguments; // Set Logging levels _asyncClassLogger.SetLoggingLevel(); // Get new strategy instance var strategyInstance = StrategyHelper.CreateStrategyInstance(_strategyType, _ctorArguments); if (strategyInstance != null) { // Cast to TradeHubStrategy Instance TradeHubStrategy = strategyInstance as TradeHubStrategy; InitializeStrategyListeners(); OverrideMarketRequestCalls(); OverrideOrderRequestCalls(); } }
/// <summary> /// Gets all possible combinations for the given parameters /// </summary> /// <param name="args">ctor arguments to create combinations with</param> /// <param name="conditionalParameters">contains info for the conditional parameters</param> /// <param name="conditionalIndex">index of conditional parameter to be used for iterations</param> private void GetAllIterations(object[] args, Tuple <int, string, string>[] conditionalParameters, int conditionalIndex) { try { // get index of parameter to be incremented int index = conditionalParameters[conditionalIndex].Item1; // Get end value for the parameter decimal endPoint; if (!decimal.TryParse(conditionalParameters[conditionalIndex].Item2, out endPoint)) { return; } // Get increment value to be used decimal increment; if (!decimal.TryParse(conditionalParameters[conditionalIndex].Item3, out increment)) { return; } // Get Orignal Value decimal orignalValue = Convert.ToDecimal(args[index]); // Iterate through all combinations for (decimal i = 0; ; i += increment) { // Modify parameter value var parameter = orignalValue + i; if (parameter > endPoint) { break; } // Convert string value to required format var value = StrategyHelper.GetParametereValue(parameter.ToString(), _parmatersDetails[index].ParameterType.Name); // Update arguments array args[index] = value; // Check if the combination is already present if (!ValueAdded(args, _ctorArguments, index)) { // Add the updated arguments to local map _ctorArguments.Add(args.Clone() as object[]); // Get further iterations if if (conditionalIndex > 0) { GetAllIterations(args.Clone() as object[], conditionalParameters, conditionalIndex - 1); } } } } catch (Exception exception) { Console.WriteLine(exception); } }
/// <summary> /// Initializes necessary fields and parameters /// </summary> /// <param name="strategyType">User Strategy Type</param> /// <param name="ctorArguments">Constructor arguments to initialize strategy</param> private void Initialize(Type strategyType, object[] ctorArguments) { _manualReset = new ManualResetEvent(false); _logger = new AsyncClassLogger("StrategyExecutorGeneticAlgo"); _logger.SetLoggingLevel(); // Save Strategy Type _strategyType = strategyType; //Save Arguments _ctorArguments = ctorArguments; // Set Logging levels _logger.SetLoggingLevel(); // Get new strategy instance var strategyInstance = StrategyHelper.CreateStrategyInstance(_strategyType, _ctorArguments); if (strategyInstance != null) { // Cast to TradeHubStrategy Instance _tradeHubStrategy = strategyInstance as TradeHubStrategy; InitializeStrategyListeners(); OverrideMarketRequestCalls(); OverrideOrderRequestCalls(); } }
public void GetAllStrategiesPathTest() { _dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1"); var strategiesPaths = StrategyHelper.GetAllStrategiesPath(); Assert.AreEqual(1, strategiesPaths.Count); Assert.AreEqual(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1\\Strategy1.dll", strategiesPaths[0]); }
public double Calculate(int firstNumber, int secondNumber, Operator operatorEnum) { var calculationExpression = $"{firstNumber}{operatorEnum}{secondNumber}"; var calculationStrategy = StrategyHelper.GetMatchingStrategy(calculationExpression); var result = calculationStrategy.GetCalculationResult(); return(result); }
public void InvalidAssemblyVerificationTest() { string assemblyPath = Path.GetFullPath( @"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Debug\TradeHub.Common.Core.dll"); Assert.IsFalse(StrategyHelper.ValidateStrategy(assemblyPath)); }
public void Start() { var number = new Number(int.MaxValue, int.MaxValue); var helper = new StrategyHelper(); logger.Info($"{number.NumberOne} + {number.NumberTwo} = {helper.DoStrategy(new Context(new Add()), number)}"); logger.Info($"{number.NumberOne} - {number.NumberTwo} = {helper.DoStrategy(new Context(new Substract()), number)}"); logger.Info($"{number.NumberOne} * {number.NumberTwo} = {helper.DoStrategy(new Context(new Multiply()), number)}"); }
public void GetAllStrategiesNameTest() { _dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1"); _dir2 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy2"); List <string> strategies = StrategyHelper.GetAllStrategiesName(); Assert.AreEqual(2, strategies.Count); Assert.AreEqual("Strategy1", strategies[0]); Assert.AreEqual("Strategy2", strategies[1]); }
public void CalculateMovingVolatility() { // Arrange var deviationsSquared = new double[] { 0, 4, 25, 4, 9, 25, 0, 1, 16, 4, 16, 0, 9, 25, 4, 9, 9, 4, 1, 4, 9 }; // Act var volatility = StrategyHelper.CalculateMovingVolatility(20, deviationsSquared, 20); // Assert Assert.AreEqual(Math.Round(volatility, 3), 3.061); }
public int GetFibonacci(int n) { bool baseCase = n == 0 || n == 1; if (baseCase) { return(n); } return(StrategyHelper.FailIfCheckedAdditionFails(GetFibonacci(n - 1), GetFibonacci(n - 2))); }
public void GetConstructorDetails_LoadAssembly_ReturnInfo_Successfull() { string assemblyPath = Path.GetFullPath( @"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Release\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll"); // Get Class Type from assembly var details = StrategyHelper.GetConstructorDetails(assemblyPath); Assert.AreEqual(details.Item2.Count(), 9, "Parameter Count"); }
private void LACPAssignmentMapper(IList <string> IndexValues, string Value, object StrategyDTOobject) { IDictionary <string, IList <string> > LACPMapping = StrategyDTOobject as IDictionary <string, IList <string> >; LACPMapping.Add(IndexValues[0], new List <string>()); string[] positions = StrategyHelper.GetFlagArrayPositions(Value); for (int i = 0; i < positions.Length; i++) { LACPMapping[IndexValues[0]].Add(positions[i]); } }
public void TestThatStrategyIsExecutingAndChangingItsStatus() { string assemblyPath = Path.GetFullPath(@"~\..\..\..\..\Lib\testing\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll"); Assert.True(File.Exists(assemblyPath)); var classtype = StrategyHelper.GetStrategyClassType(assemblyPath); var parametersDetails = StrategyHelper.GetParameterDetails(classtype); Dictionary <string, ParameterDetail> parameters = new Dictionary <string, ParameterDetail>(); parameters.Add("1", new ParameterDetail(typeof(int), 10)); parameters.Add("2", new ParameterDetail(typeof(int), 15)); parameters.Add("3", new ParameterDetail(typeof(string), "LAST")); parameters.Add("4", new ParameterDetail(typeof(string), "ERX")); parameters.Add("5", new ParameterDetail(typeof(decimal), 1000)); parameters.Add("6", new ParameterDetail(typeof(string), BarFormat.TIME)); parameters.Add("7", new ParameterDetail(typeof(string), BarPriceType.LAST)); parameters.Add("8", new ParameterDetail(typeof(string), TradeHubConstats.MarketDataProvider.SimulatedExchange)); parameters.Add("9", new ParameterDetail(typeof(string), TradeHubConstats.OrderExecutionProvider.SimulatedExchange)); object[] paramters = { (int)10, (int)15, (string)"LAST", (string)"ERX", (decimal)1000, BarFormat.TIME, BarPriceType.LAST, TradeHubConstats.MarketDataProvider.SimulatedExchange, TradeHubConstats.OrderExecutionProvider.SimulatedExchange }; var instance = StrategyHelper.CreateStrategyInstance(classtype, paramters); StrategyInstance strategyInstance = new StrategyInstance(); strategyInstance.InstanceKey = "A00"; strategyInstance.Parameters = parameters; strategyInstance.StrategyType = classtype; strategyInstance.Symbol = "ERX"; StrategyController controller = new StrategyController(); StrategyStatusRepresentation statusRepresentationrepresentation = null; ManualResetEvent resetEvent = new ManualResetEvent(false); controller.StrategyStatusChanged += delegate(StrategyStatusRepresentation representation) { statusRepresentationrepresentation = representation; resetEvent.Set(); }; controller.AddStrategyInstance(strategyInstance); resetEvent.WaitOne(5000); controller.RunStrategy(strategyInstance.InstanceKey); resetEvent.WaitOne(2000); Assert.NotNull(statusRepresentationrepresentation); Assert.AreEqual(StrategyStatus.Executing, statusRepresentationrepresentation.StrategyStatus); }
/// <summary> /// Get all saved strategies /// </summary> /// <returns></returns> public List <Strategy> GetAllStrategies() { List <Strategy> savedStrategies = new List <Strategy>(); //get all saved strategies var strategies = StrategyHelper.GetAllStrategiesName(); //cast all strategies names to its object foreach (var strategy in strategies) { //savedStrategies.Add(new Strategy(){Key = strategy}); } return(savedStrategies); }
/// <summary> /// Returns IList of actual parameter values from the Parameter Details object /// </summary> /// <returns></returns> public IList <object> GetParameterValues(Dictionary <string, ParameterDetail> parameterDetails) { IList <object> parameterValues = new List <object>(); // Traverse all parameter foreach (KeyValuePair <string, ParameterDetail> keyValuePair in parameterDetails) { // Makes sure all parameters are in right format var input = StrategyHelper.GetParametereValue(keyValuePair.Value.ParameterValue.ToString(), keyValuePair.Value.ParameterType.Name); // Add actual parameter values to the new object list parameterValues.Add(input); } return(parameterValues); }
/// <summary> /// 运行策略,并且将策略运行结果绑定到该 /// </summary> public void Run() { if (this.strategyData == null || this.strategyData.Strategy == null) { return; } IStrategy strategy = this.strategyData.Strategy; StrategyReferedPeriods referedPeriods = strategy.GetReferedPeriods(); if (referedPeriods == null) { referedPeriods = new StrategyReferedPeriods(); KLinePeriod currentPeriod = this.compChart.Controller.ChartComponentData.KlinePeriod; referedPeriods.UsedKLinePeriods.Add(currentPeriod); if (strategy is StrategyAbstract) { ((StrategyAbstract)strategy).MainKLinePeriod = currentPeriod; } } KLinePeriod mainPeriod = referedPeriods.MainPeriod; StrategyForwardPeriod forwardPeriod = new StrategyForwardPeriod(referedPeriods.UseTickData, mainPeriod); IStrategyExecutorFactory executorFactory = StrategyCenter.Default.GetStrategyExecutorFactory(); IDataPackage_Code dataPackage = this.compChart.Controller.CurrentNavigater.DataPackage; Dictionary <KLinePeriod, int> dic_KLinePeriod_StartPos = new Dictionary <KLinePeriod, int>(); for (int i = 0; i < referedPeriods.UsedKLinePeriods.Count; i++) { KLinePeriod period = referedPeriods.UsedKLinePeriods[i]; dic_KLinePeriod_StartPos.Add(period, dataPackage.GetKLineData(period).BarPos); } drawOperator = new ChartComponentStrategyDrawer(this.compChart.Drawer, dic_KLinePeriod_StartPos, 0, 0); StrategyArguments_DataPackage strategyDataPackage = new StrategyArguments_DataPackage(dataPackage, referedPeriods, forwardPeriod);; StrategyHelper strategyOperator = new StrategyHelper(); strategyOperator.Drawer = drawOperator; strategyExecutor = executorFactory.CreateExecutor_History(strategyDataPackage); strategyExecutor.Strategy = strategy; //strategyExecutor.Run(); //strategyExecutor.ExecuteFinished += StrategyExecutor_ExecuteFinished; strategyExecutor.Execute(); }
private void GetLearnedMACAddresses(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo) { IOIDSettingDTO SelectedSetting; IList <Action <IList <string>, string, object> > MappingHandlers; //Get setting of interest SelectedSetting = OIDSettings["LearnedMACByPhysPortID"]; //Define handle collection in order MappingHandlers = new List <Action <IList <string>, string, object> >(); MappingHandlers.Add(LearnedAddressMapper); //Initialize container if necesary TopologyInfo.PortLearnedAddresses = new Dictionary <string, IDictionary <string, string> >(); //Collect data mapping with handlers StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers); }
protected override void OnStrategyStart() { StrategyHelper = new StrategyHelper(framework, this); StrategyHelper.OpenCloseHelper = new OpenCloseHelper(framework, this); //StrategyHelper.PriceHelper = new PriceHelper(framework, 0.001); //StrategyHelper.TimeHelper = new TimeHelper(Instrument.Symbol); //StrategyHelper.MarketOrderType = SmartQuant.OrderType.Limit; //StrategyHelper.Tick = 10; StrategyHelper.OpenCloseHelper.SeparateOrder = SeparateOrder.SeparateCloseOpen; StrategyHelper.OpenCloseHelper.DefaultClose = DefaultClose.CloseToday; StrategyHelper.OpenCloseHelper.SendStyle = SendStyle.OneByOne; //StrategyHelper.EnableTrading = true; //StrategyHelper.EnableLongEntry = true; //StrategyHelper.EnableShortEntry = true; }
private void GetPortMACAddress(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo) { IOIDSettingDTO SelectedSetting; IList <Action <IList <string>, string, object> > MappingHandlers; //Get setting of interest SelectedSetting = OIDSettings["PhysPortMACAddress"]; //Define handle collection in order MappingHandlers = new List <Action <IList <string>, string, object> >(); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortMACAddress.Add(x[0], y); }); //Define container if necesary TopologyInfo.PortMACAddress = new Dictionary <string, string>(); //Collect data mapping with handlers StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers); }
/// <summary> /// Returns IList of actual parameter values from the Parameter Details object /// </summary> /// <returns></returns> public object[] GetParameterValues() { int entryCount = 0; object[] parameterValues = new object[Parameters.Count]; // Traverse all parameter foreach (KeyValuePair <string, ParameterDetail> keyValuePair in Parameters) { // Makes sure all parameters are in right format var input = StrategyHelper.GetParametereValue(keyValuePair.Value.ParameterValue.ToString(), keyValuePair.Value.ParameterType.Name); // Add actual parameter values to the new object list parameterValues[entryCount++] = input; } return(parameterValues); }
/// <summary> /// Returns Initial Parameter values /// </summary> /// <returns></returns> public object[] GetParameterValues() { int entryCount = 0; object[] parameterValues = new object[ParameterDetails.Count]; // Traverse all parameter foreach (BruteForceParameterDetail iteratorVariable in ParameterDetails) { // Makes sure all parameters are in right format var input = StrategyHelper.GetParametereValue(iteratorVariable.ParameterValue.ToString(), iteratorVariable.ParameterType.Name); // Add actual parameter values to the new object list parameterValues[entryCount++] = input; } return(parameterValues); }
/// <summary> /// Loads and Initializes "TradeHub" strategy from the given assembly /// </summary> /// <param name="path">Assembly path</param> public void LoadAssembly(string path) { try { // Load Assembly file from the selected file Assembly assembly = Assembly.LoadFrom(path); var strategyDetails = StrategyHelper.GetConstructorDetails(path); if (strategyDetails == null) { Console.WriteLine("NULL value in strategy details"); return; } // Get Strategy Type _strategyType = strategyDetails.Item1; //// Verify Strategy Instance //if (_tradeHubStrategy == null) //{ // // Get new strategy instance // var strategyInstance = LoadCustomStrategy.CreateStrategyInstance(_strategyType, _ctorArguments); // if (strategyInstance != null) // { // // Cast to TradeHubStrategy Instance // _tradeHubStrategy = strategyInstance as TradeHubStrategy; // } // if (_tradeHubStrategy == null) // { // Console.WriteLine("Unable to initialize Custom Strategy: " + _strategyType.FullName); // // Skip execution of further actions // return; // } //} } catch (Exception exception) { Console.WriteLine(exception); } }
private void GetAggregateDestinations(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo) { IOIDSettingDTO SelectedSetting; IList <Action <IList <string>, string, object> > MappingHandlers; //Get setting of interest SelectedSetting = OIDSettings["TrunkDestinationsCDP"]; //Define handle collection in order MappingHandlers = new List <Action <IList <string>, string, object> >(); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortAggregateDestinations.Add(x[0], new CustomPair <string, string>(y, null)); }); MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortAggregateDestinations[x[0]].Second = y; }); //Define container if necesary TopologyInfo.PortAggregateDestinations = new Dictionary <string, CustomPair <string, string> >(); //Collect data mapping with handlers StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers); }
/// <summary> /// Verify and add strategy to TradeHub /// </summary> /// <param name="assemblyPath"></param> /// <returns></returns> public bool VerifyAndAddStrategy(string assemblyPath) { if (Logger.IsInfoEnabled) { Logger.Info("Received call for adding strategy, path=" + assemblyPath, _type.FullName, "VerifyAndAddStrategy"); } if (StrategyHelper.ValidateStrategy(assemblyPath)) { StrategyHelper.CopyAssembly(assemblyPath); if (Logger.IsInfoEnabled) { Logger.Info("Strategy Added", _type.FullName, "VerifyAndAddStrategy"); } return(true); } return(false); }
private Sbr FindBestResponse(StrategyHelper strHelper, int pos, GameDefinition gd, Sbr.CreateRootGenNodeDelegate createRootGenNodeDelegate) { Sbr br = new Sbr(); br.GameDef = gd; br.HeroPosition = pos; if (createRootGenNodeDelegate != null) { br.CreateRootGenNode = createRootGenNodeDelegate; } strHelper.SetProbabilityOfOppAction(); br.SetOppStrategy(1 - pos, strHelper.OppStrategy.ToArray()); br.Calculate(); return(br); }