public static void TrySetStrategy(StrategyInterface strategy) { if (breakMode == BreakMode.None || locationType != LocationType.Platform) { return; } BreakPoint bp; switch (constraintType) { case ConstraintType.Strategy: if (strategy.Name == constraint) { bp = new BreakPoint(); bp.strategy = strategy; strategy.AddInterceptor(bp); } break; case ConstraintType.Symbol: if (strategy.SymbolDefault == constraint) { bp = new BreakPoint(); bp.strategy = strategy; strategy.AddInterceptor(bp); } break; default: bp = new BreakPoint(); bp.strategy = strategy; strategy.AddInterceptor(bp); break; } }
void UpdatePosition(float deltaTime) { Vector2 vertical = new Vector2(); float speed = controllable.speed; TransformBase tr = controllable.transform; // Test strategy pattern if (elapsedTime < 3f) { action = new MoveForward(); action.DoAction(tr, ref vertical, speed, deltaTime); } else if (elapsedTime >= 3f && elapsedTime < 4.8f) { action = new TurnRight(); action.DoAction(tr, ref vertical, speed, deltaTime); } else if (elapsedTime >= 4.8f && elapsedTime < 6.6f) { action = new TurnLeft(); action.DoAction(tr, ref vertical, speed, deltaTime); } else if (elapsedTime >= 6.6f && elapsedTime < 9.6f) { action = new MoveBackwards(); action.DoAction(tr, ref vertical, speed, deltaTime); } else if (elapsedTime >= 9.6f) { elapsedTime = 0; } tr.position += Utils.Rotate(vertical, tr.rotation); controllable.transform = tr; }
internal IEnumerable <StrategyInterface> GetStrategyList(Chain chain) { StrategyInterface currentStrategy = chain.Model as StrategyInterface; if (currentStrategy != null) { yield return(currentStrategy); } foreach (Chain tempChain in chain.Dependencies) { if (tempChain == chain) { throw new ApplicationException("Found recursive loop. " + tempChain.Model.Name + " cannot be a dependency of itself."); } foreach (StrategyInterface strategy in GetStrategyList(tempChain.Tail)) { yield return(strategy); } } if (chain.Previous.Model != null) { foreach (StrategyInterface strategy in GetStrategyList(chain.Previous)) { yield return(strategy); } } }
public virtual void Init() { this.strategy = Factory.Utility.Strategy(); this.strategy.Context = new MockContext(); string appData = Factory.Settings["AppDataFolder"]; // File.Delete( Factory.SysLog.LogFolder + @"\" + assemblyName+"Tests.log"); // File.Delete( Factory.SysLog.LogFolder + @"\" + assemblyName+".log"); }
public LogicalOrder CreateOrder(StrategyInterface strategy, TradeDirection tradeDirection, OrderType orderType, double price, int position, int strategyPosition) { LogicalOrder order = Factory.Engine.LogicalOrder(symbol, strategy); order.StrategyId = 1; order.StrategyPosition = strategyPosition; order.TradeDirection = tradeDirection; order.Type = orderType; order.Price = price; order.Position = position * lotSize; order.Status = OrderStatus.Active; orders.AddLast(order); strategy.Position.Change(strategyPosition, 100.00, TimeStamp.UtcNow); return(order); }
private void SetupWatcher(StrategyInterface strategy) { if (portfolioType == PortfolioType.SingleSymbol) { strategy.OnActiveChange += HandleActiveChange; strategy.AddEventListener(EventType.LogicalFill, this); } var watcher = new StrategyWatcher(strategy); watchers.Add(strategy, watcher); if (strategy.IsActive) { activeWatchers.Add(watcher); } }
public bool SetOptimizeValues(ModelLoaderInterface loader) { // Then set them for logging separately to optimization reports. Dictionary <string, object> optimizeValues = new Dictionary <string, object>(); for (int i = 0; i < loader.Variables.Count; i++) { optimizeValues[loader.Variables[i].Name] = loader.Variables[i].Value; } bool retVal = true; foreach (var kvp in optimizeValues) { string name = kvp.Key; object value = kvp.Value; string[] namePairs = kvp.Key.Split('.'); if (namePairs.Length < 2) { log.Error("Sorry, the optimizer variable '" + kvp.Key + "' was not found."); retVal = false; continue; } string strategyName = namePairs[0]; StrategyInterface strategy = null; foreach (StrategyInterface tempStrategy in GetStrategyList(loader.TopModel.Chain.Tail)) { if (tempStrategy.Name.CompareWildcard(strategyName, false)) { strategy = tempStrategy; if (!SetOptimizeValue(strategy, name, value)) { retVal = false; break; } } } if (strategy == null) { log.Error("Sorry, a strategy matching '" + strategyName + "' was never found for optimizer variable '" + kvp.Key + "'."); retVal = false; continue; } } optimizeValueMap.Add(loader.TopModel, optimizeValues); return(retVal); }
public void ProcessFill(StrategyInterface strategyInterface, LogicalFill fill) { if (debug) { Log.Debug("ProcessFill: " + fill + " for strategy " + strategyInterface); } var strategy = (Strategy)strategyInterface; int orderId = fill.OrderId; LogicalOrder filledOrder = null; if (strategyInterface.TryGetOrderById(fill.OrderId, out filledOrder)) { if (debug) { Log.Debug("Matched fill with orderId: " + orderId); } if (!doStrategyOrders && filledOrder.TradeDirection != TradeDirection.ExitStrategy) { if (debug) { Log.Debug("Skipping fill, strategy order fills disabled."); } return; } if (!doExitStrategyOrders && filledOrder.TradeDirection == TradeDirection.ExitStrategy) { if (debug) { Log.Debug("Skipping fill, exit strategy orders fills disabled."); } return; } TryDrawTrade(filledOrder, fill.Price, fill.Position); if (debug) { Log.Debug("Changed strategy position to " + fill.Position + " because of fill."); } changePosition(strategy.Data.SymbolInfo, fill); } else { throw new ApplicationException("A fill for order id: " + orderId + " was incorrectly routed to: " + strategyInterface.Name); } }
public void WritePassStats(StreamWriter fwriter, StrategyInterface passModel) { Dictionary <string, object> optimizeValues = optimizeValueMap[passModel]; if (!headerWritten) { headerWritten = true; string header = passModel.OnGetOptimizeHeader(optimizeValues); if (string.IsNullOrEmpty(header)) { log.Warn("The header string returned from OnGetOptimizeResults for " + passModel.Name + " was empty or null."); } else { fwriter.WriteLine(header); } } string stats = passModel.OnGetOptimizeResult(optimizeValues); if (stats != null && stats.Length > 0) { fwriter.WriteLine(stats); } }
public StrategyWatcher(StrategyInterface strategy) { this.strategy = strategy; this.position = strategy.Result.Position; }
public FillHandlerDefault(StrategyInterface strategyInterface) { Strategy strategy = (Strategy)strategyInterface; graphTrades = strategy.Performance.GraphTrades; }
internal FillManager(StrategyInterface strategy) { this.Strategy = strategy; this.changePosition = strategy.Position.Change; }
public LogicalOrder CreateEntry(StrategyInterface strategy, SymbolInfo symbol, OrderType orderType, double price, int position, int strategyPosition) { return(CreateOrder(strategy, symbol, TradeDirection.Entry, orderType, price, position, strategyPosition)); }
public Context(StrategyInterface strategy) { this.strategy = strategy; }
public FillHandler FillHandler(StrategyInterface strategy) { return(new FillHandlerDefault(strategy)); }
public LimeProviderTests(string name) { testName = name; Strategy = Factory.Utility.Strategy(); Strategy.Context = new MockContext(); }
public LogicalOrder CreateExit(StrategyInterface strategy, OrderType orderType, double price, int strategyPosition) { return(CreateOrder(strategy, TradeDirection.Exit, orderType, price, 0, strategyPosition)); }
public LogicalOrder CreateChange(StrategyInterface strategy, OrderType orderType, double price, int position, int strategyPosition) { return(CreateOrder(strategy, TradeDirection.Change, orderType, price, position, strategyPosition)); }
private static List <Tuple <double, User> > nearestNeighbours(User selectedUser, List <int> emptyRatings, double smt, int amount) { List <Tuple <double, User> > nn_Euclidian = new List <Tuple <double, User> >(); var nn_Pearson = new List <Tuple <double, User> >(); List <Tuple <double, User> > nn_Cosine = new List <Tuple <double, User> >(); //loop through all the users and find the users that are most similar to selecteduser foreach (var user in userpref) { var user2 = userpref[user.Key]; if (selectedUser.id != user.Key) { var difference = 0; foreach (var rating in emptyRatings) { if (user2.articleRating[rating] != 0) { difference++; } } if (difference <= 0) { continue; } //TODO refactor this mess, only pearson has treshold atm Console.WriteLine("Compare user: "******" with user: "******"---------------------"); ed = new EuclidianDistance(); var euclidian_distance = ed.calculate(selectedUser, user2, uniqueArticles); user2.euclidean_distance = euclidian_distance; nn_Euclidian.Add(Tuple.Create(euclidian_distance, user2)); Console.WriteLine("Euclidian stuff: " + euclidian_distance); pe = new Pearsons(); var correlation = pe.calculate(selectedUser, user2, uniqueArticles); if (correlation >= smt) { var neighbour = Tuple.Create(correlation, user2); if (nn_Pearson.Count < amount) { nn_Pearson.Add(neighbour); if (nn_Pearson.Count() == amount) { smt = nn_Pearson.Min(x => x.Item1); } } else { nn_Pearson.Add(neighbour); var lowestSimilarityUser = nn_Pearson.OrderBy(x => x.Item1).First(); nn_Pearson.Remove(lowestSimilarityUser); smt = nn_Pearson.OrderBy(x => x.Item1).First().Item1; } } Console.WriteLine("Pearsons corr: " + correlation); co = new Cosine(); var cosine_similarity = co.calculate(selectedUser, user2, uniqueArticles); user2.cosine = cosine_similarity; nn_Cosine.Add(Tuple.Create(cosine_similarity, user2)); Console.WriteLine("Cosine similarity: " + cosine_similarity + "\n"); } else { continue; } } //maybe print the first 3 of this stuff List <Tuple <double, User> > nn_Euclidian_Sorted = nn_Euclidian.OrderByDescending(x => x.Item1).ToList(); List <Tuple <double, User> > nn_Pearson_Sorted = nn_Pearson.OrderByDescending(x => x.Item1).ToList(); List <Tuple <double, User> > nn_Cosine_Sorted = nn_Cosine.OrderByDescending(x => x.Item1).ToList(); for (var i = 0; i < amount_nearestNeighbours; i++) { Console.WriteLine("Nearest {0}", i + 1 + "\n----------------"); Console.WriteLine("Euclidian nn: " + nn_Euclidian_Sorted[i].Item2.id); Console.WriteLine("Pearson nn: " + nn_Pearson_Sorted[i].Item2.id); Console.WriteLine("consine nn: " + nn_Cosine_Sorted[i].Item2.id + "\n"); } return(nn_Pearson_Sorted); }
private bool SetOptimizeValue(StrategyInterface strategy, string name, object value) { string[] namePairs = name.Split('.'); string propertyName = namePairs[1]; PropertyDescriptorCollection props = TypeDescriptor.GetProperties(strategy); PropertyDescriptor property = null; for (int i = 0; i < props.Count; i++) { PropertyDescriptor tempProperty = props[i]; if (tempProperty.Name == propertyName) { property = tempProperty; break; } } if (property == null) { log.Error("Sorry, the optimizer variable '" + name + "' was not found."); return(false); } if (namePairs.Length == 2) { if (!SetProperty(strategy, property, value)) { log.Error("Sorry, the value '" + value + "' isn't valid for optimizer variable '" + name + "'."); return(false); } } else if (namePairs.Length == 3) { StrategyInterceptorInterface strategySupport = property.GetValue(strategy) as StrategyInterceptorInterface; if (strategySupport == null) { log.Error("Sorry, the optimizer variable '" + name + "' was not found."); return(false); } string strategySupportName = namePairs[1]; propertyName = namePairs[2]; props = TypeDescriptor.GetProperties(strategySupport); property = null; for (int i = 0; i < props.Count; i++) { PropertyDescriptor tempProperty = props[i]; if (tempProperty.Name == propertyName) { property = tempProperty; break; } } if (property == null) { log.Error("Sorry, the optimizer variable '" + name + "' was not found."); return(false); } if (!SetProperty(strategySupport, property, value)) { log.Error("Sorry, the value '" + value + "' isn't valid for optimizer variable '" + name + "'."); return(false); } } return(true); }
public FillHandlerDefault(StrategyInterface strategyInterface) { this.strategy = (Strategy)strategyInterface; log.Register(this); }