internal override ThreeValuedLogic Evaluate(Strategy strategy) { var association = strategy.GetCompositeAssociation(this.associationType); return (association != null && association.Equals(this.equals)) ? ThreeValuedLogic.True : ThreeValuedLogic.False; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { var compareValue = this.compare; var compareRole = this.compare as IRoleType; if (compareRole != null) { compareValue = strategy.GetInternalizedUnitRole(compareRole); } else { if (this.roleType.ObjectType is IUnit) { compareValue = this.roleType.Normalize(this.compare); } } var comparable = strategy.GetInternalizedUnitRole(this.roleType) as IComparable; if (comparable == null) { return ThreeValuedLogic.Unknown; } return comparable.CompareTo(compareValue) < 0 ? ThreeValuedLogic.True : ThreeValuedLogic.False; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { bool unknown = false; foreach (Predicate filter in this.Filters) { if (filter.Include) { switch (filter.Evaluate(strategy)) { case ThreeValuedLogic.True: return ThreeValuedLogic.True; case ThreeValuedLogic.Unknown: unknown = true; break; } } } if (unknown) { return ThreeValuedLogic.Unknown; } return ThreeValuedLogic.False; }
public void Record(IMdsDescriptor sequence, Strategy strategy ) { Total++; if(sequence.IsSuccessful) { Successful++; } }
/// <summary> /// Initializes a new instance of the <see cref="StrategyNameGenerator"/>. /// </summary> /// <param name="strategy">Strategy.</param> public StrategyNameGenerator(Strategy strategy) { if (strategy == null) throw new ArgumentNullException("strategy"); _strategy = strategy; _strategy.SecurityChanged += () => { if (_selectors.Contains("Security")) Refresh(); }; _strategy.PortfolioChanged += () => { if (_selectors.Contains("Portfolio")) Refresh(); }; ShortName = new string(_strategy.GetType().Name.Where(char.IsUpper).ToArray()); _formatter = Smart.CreateDefaultSmartFormat(); _formatter.SourceExtensions.Add(new Source(_formatter, new Dictionary<string, string> { { "FullName", _strategy.GetType().Name }, { "ShortName", ShortName }, })); _selectors = new SynchronizedSet<string>(); AutoGenerateStrategyName = true; Pattern = "{ShortName}{Security:_{0.Security}|}{Portfolio:_{0.Portfolio}|}"; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { if (this.associationType.IsMany) { var associations = strategy.GetCompositeAssociations(this.associationType); foreach (var assoc in associations) { if (this.containingExtent.Contains(assoc)) { return ThreeValuedLogic.True; } } return ThreeValuedLogic.False; } var association = strategy.GetCompositeAssociation(this.associationType); if (association != null) { return this.containingExtent.Contains(association) ? ThreeValuedLogic.True : ThreeValuedLogic.False; } return ThreeValuedLogic.False; }
public UIController(List<BrokerManager> b, PositionManager pos, MainWindow w) { runningStrategy = null; cummulativePnL = 0; win = w; brokers = b; pos.PositionChange += new PositionChangedEventHandler(positionChange); pos.TradeMatched += new TradeMatchedEventHandler(tradeMatched); win.StrategyStart += new StrategyStartDelegate(startStrategy); win.StrategyStop += new StrategyStopDelegate(stopStrategy); //register to receive events from brokers foreach (BrokerManager brk in brokers) { brk.FillUpdate += new FillEventHandler(fillReceived); brk.OrderConfirmed += new OrderConfirmEventHandler(orderConfirmed); brk.RiskFilterFailure += new RiskFilterFailureEventHandler(riskFilterFailed); brk.LastUpdate += new LastUpdateEventHandler(lastUpdate); } Dictionary<int, String> strategyMap = new Dictionary<int, String>(); strategyMap.Add(0, "Buy & Hold"); strategyMap.Add(1, "Pair Trade"); win.availableStrategies = strategyMap; }
private void OnChildStrategiesAdded(Strategy strategy) { var rule = strategy .WhenStopped() .Do(s => { if (FinishMode == BasketStrategyFinishModes.First) { if (FirstFinishStrategy == null) { FirstFinishStrategy = s; Stop(); } } else { if (ChildStrategies.SyncGet(c => c.All(child => child.ProcessState != ProcessStates.Started))) Stop(); } }) .Once() .Apply(this); rule.UpdateName(rule.Name + " (BasketStrategy.OnChildStrategiesAdded)"); }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { var containing = new HashSet<IObject>(this.containingEnumerable); if (this.associationType.IsMany) { var associations = strategy.GetCompositeAssociations(this.associationType); foreach (var assoc in associations) { if (containing.Contains((IObject)assoc)) { return ThreeValuedLogic.True; } } return ThreeValuedLogic.False; } var association = strategy.GetCompositeAssociation(this.associationType); if (association != null) { return containing.Contains(association) ? ThreeValuedLogic.True : ThreeValuedLogic.False; } return ThreeValuedLogic.False; }
/// <summary> /// Constructor /// </summary> /// <param name="run">Run</param> /// <param name="strategy">Strategy</param> public BackoffRunner(IDynamicRuns run, Strategy strategy = Strategy.Exponential) : base(run.MinimumPeriodInSeconds, run.MaximumPeriodInSeconds, strategy) { this.run = run; base.Name = string.Format("{0}+{1}", this.GetType(), this.run.GetType()); }
public static void Main(string[] args) { string inputname = args[0]; string outputname = args[1]; string[] lines = File.ReadAllLines(inputname); int ncases = int.Parse(lines[0]); IList<string> results = new List<string>(); Strategy strat = new Strategy(); int nline = 0; for (int k = 0; k < ncases; k++) { nline++; int nnumbers = int.Parse(lines[nline].Trim()); nline++; var first = lines[nline].Trim().Split(' ').Select(n => double.Parse(n)).ToList(); nline++; var second = lines[nline].Trim().Split(' ').Select(n => double.Parse(n)).ToList(); int nwinwar = strat.CalculateWar(first, second); int nwindwar = strat.CalculateDeceitfulWar(first, second); results.Add(string.Format("Case #{0}: {1} {2}", k + 1, nwindwar, nwinwar)); } File.WriteAllLines(outputname, results.ToArray()); }
public StrategyItem(Strategy strategy) { if (strategy == null) throw new ArgumentNullException(nameof(strategy)); Strategy = strategy; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { var value = strategy.GetInternalizedUnitRole(this.roleType); if (value == null) { return ThreeValuedLogic.Unknown; } var equalsValue = this.equals; if (this.equals is IRoleType) { var equalsRole = (IRoleType)this.equals; equalsValue = strategy.GetInternalizedUnitRole(equalsRole); } else { if (this.roleType.ObjectType is IUnit) { equalsValue = RoleTypeExtensions.Normalize(this.roleType, this.@equals); } } if (equalsValue == null) { return ThreeValuedLogic.False; } return value.Equals(equalsValue) ? ThreeValuedLogic.True : ThreeValuedLogic.False; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { object value = strategy.GetCompositeRole(this.roleType); if (value == null) { return ThreeValuedLogic.False; } object equalsValue = this.equals; if (this.equals is IRoleType) { var equalsRole = (IRoleType)this.equals; equalsValue = strategy.GetCompositeRole(equalsRole); } if (equalsValue == null) { return ThreeValuedLogic.False; } return value.Equals(equalsValue) ? ThreeValuedLogic.True : ThreeValuedLogic.False; }
public static void Main(string[] args) { var strategy = new Strategy(5); var result = strategy.Go().Result; Console.WriteLine($"Result: {result}"); }
public void CalculateSimpleWarWin() { Strategy strat = new Strategy(); var result = strat.CalculateWar(new double[] { 0.2 }, new double[] { 0.1 }); Assert.AreEqual(1, result); }
public void CalculateWarCaseFour() { Strategy strat = new Strategy(); var result = strat.CalculateWar(new double[] { 0.186, 0.389, 0.907, 0.832, 0.959, 0.557, 0.300, 0.992, 0.899 }, new double[] { 0.916, 0.728, 0.271, 0.520, 0.700, 0.521, 0.215, 0.341, 0.458 }); Assert.AreEqual(4, result); }
public void CalculateDeceitfulWarCaseTwo() { Strategy strat = new Strategy(); var result = strat.CalculateDeceitfulWar(new double[] { 0.7, 0.2 }, new double[] { 0.8, 0.3 }); Assert.AreEqual(1, result); }
public void Record(IMdsDescriptor sequence, Strategy strategy ) { if(writer!=null) { writer.WriteLine("{0} {1} => {2}", sequence.IsSuccessful?"SUCCESS":"FAILURE", strategy, sequence); } if(wrappedLogger==null) return; wrappedLogger.Record(sequence,strategy); }
public void CalculateDeceitfulWarCaseThree() { Strategy strat = new Strategy(); var result = strat.CalculateDeceitfulWar(new double[] { 0.5, 0.1, 0.9 }, new double[] { 0.6, 0.4, 0.3 }); Assert.AreEqual(2, result); }
public static void setStrategy(Strategy s ){ BallScript.strategy = s; if (s.GetType()== new secondStrategy().GetType()) { Debug.Log("sec strategy"); BallScript.strategy=new secondStrategy(); } }
public void CalculateDeceitfulWarCaseOne() { Strategy strat = new Strategy(); var result = strat.CalculateDeceitfulWar(new double[] { 0.5 }, new double[] { 0.6 }); Assert.AreEqual(0, result); }
public MsilSymbolManager(ICommandLine commandLine, IFilter filter, log4net.ILog logger, Strategy.ITrackedMethodStrategyManager trackedMethodStrategyManager) { _commandLine = commandLine; _filter = filter; _logger = logger; _trackedMethodStrategyManager = trackedMethodStrategyManager; _methods = new Dictionary<int, MethodDefinition>(); }
private void ResetTree() { currentStrategy = null; currentState = Names.STATE_IDLE; treeLevel = 0; jobDone = false; //Debug.Log("Reset Tree."); }
public BaseEnemy(string name, int attack, Strategy strategy) { this.health = 20; this.name = name; this.attack = attack; this.strategy = strategy; this.speed = Random.Range(9, 15); //TODO: CHANGE THIS this.xp = 20; }
/// <summary> /// Finds the first child element matching the given mechanism and value. /// </summary> /// <param name="strategy">The mechanism by which to find the elements.</param> /// <param name="value">The value to use to search for the elements.</param> /// <param name="timeout">Optional timeout in milliseconds</param> /// <param name="raise"></param> /// <returns>WebElement</returns> public WebElement FindElementBy(Strategy strategy, string value, int timeout = -1, bool raise = true) { try { return FindFirstElement(strategy, value, timeout); } catch (Errors.NoSuchElementError) { if (raise) throw new Errors.NoSuchElementError(strategy, value); return null; } }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { var roles = strategy.GetCompositeRoles(this.roleType); if (roles != null) { return roles.Contains(this.containedObject) ? ThreeValuedLogic.True : ThreeValuedLogic.False; } return ThreeValuedLogic.False; }
/// <summary> /// Constructor for use in code when optimizing remapping. /// </summary> /// <param name="character">Character information</param> /// <param name="plan">Plan to optimize for</param> /// <param name="strategy">Optimization strategy</param> /// <param name="name">Title of this form</param> /// <param name="description">Description of the optimization operation</param> public AttributesOptimizationForm(Character character, BasePlan plan, Strategy strategy, string name, string description) : this() { m_character = character; m_baseCharacter = character.After(plan.ChosenImplantSet); m_strategy = strategy; m_plan = plan; m_description = description; Text = name; }
internal override ThreeValuedLogic Evaluate(Strategy strategy) { if (this.equals == null) { return ThreeValuedLogic.False; } return this.equals.Equals(strategy.GetObject()) ? ThreeValuedLogic.True : ThreeValuedLogic.False; }
public BackgroundObject(Texture2D texture, Vector2 position, float rotation, float size, Strategy strategy) { _sprite = new Sprite(texture); Position = position; _sprite.Position = position; _sprite.Scale = new Vector2(size); _sprite.Color = ColorFromSize(size); _sprite.CenterOrigin(); _rotation = rotation; _strategy = strategy; }
public Stop(Strategy strategy, Position position, double level, StopType type, StopMode mode) : this(strategy, position, DateTime.MinValue, level, type, mode) { }
public Stop(Strategy strategy, Position position, DateTime time) : this(strategy, position, time, 0, StopType.Trailing, StopMode.Percent) { }
public ProcessSystemConfigParser(string nodeName, Types typeDefs, IEnumerable <FuncSpec> strategyFuncs) { strategyFuncs = strategyFuncs ?? new FuncSpec[0]; this.nodeName = nodeName; this.types = typeDefs; this.clusterType = types.Register(BuildClusterType()); this.processType = types.Register(BuildProcessType()); this.routerType = types.Register(BuildRouterType()); this.strategyType = types.Register(BuildStrategySpec(types, strategyFuncs)); var opChars = ":!%&*+.<=>\\^|-~"; // Process config definition Definition = GenLanguageDef.Empty.With( CommentStart: "/*", CommentEnd: "*/", CommentLine: "//", NestedComments: true, OpStart: oneOf(opChars), OpLetter: oneOf(opChars), IdentStart: letter, IdentLetter: either(alphaNum, oneOf("-_")), ReservedNames: List("if", "then", "else").AddRange(types.AllInOrder.Map(t => t.Name)), ReservedOpNames: List("-", "+", "/", "*", "==", "!=", ">", "<", "<=", ">=", "||", "&&", "|", "&", "%", "!", "~", "^") ); // Token parser // This builds the standard token parser from the definition above TokenParser = makeTokenParser(Definition); identifier = TokenParser.Identifier; stringLiteral = TokenParser.StringLiteral; integer = TokenParser.Integer; floating = TokenParser.Float; natural = TokenParser.Natural; whiteSpace = TokenParser.WhiteSpace; symbol = TokenParser.Symbol; reserved = TokenParser.Reserved; reservedOp = TokenParser.ReservedOp; // Binary operator parser Func <string, Assoc, Operator <ValueToken> > binary = (name, assoc) => Operator.Infix(assoc, from x in reservedOp(name) select ValueToken.BinaryOp(name)); // Prefix operator parser Func <string, Operator <ValueToken> > prefix = (name) => Operator.Prefix( from x in reservedOp(name) select ValueToken.PrefixOp(name)); // Postfix operator parser Func <string, Operator <ValueToken> > postfix = (name) => Operator.Postfix( from x in reservedOp(name) select ValueToken.PostfixOp(name)); // Operator table Operator <ValueToken>[][] table = { new [] { prefix("-"), prefix("+"), prefix("!") }, new [] { binary("*", Assoc.Left), binary("/", Assoc.Left), binary("%", Assoc.Left)}, new [] { binary("+", Assoc.Left), binary("-", Assoc.Left)}, new [] { binary("<", Assoc.Left), binary(">", Assoc.Left), binary(">=", Assoc.Left), binary("<=", Assoc.Left)}, new [] { binary("==", Assoc.Left), binary("!=", Assoc.Left)}, new [] { binary("&", Assoc.Left) }, new [] { binary("^", Assoc.Left) }, new [] { binary("|", Assoc.Left) }, new [] { binary("&&", Assoc.Left) }, new [] { binary("||", Assoc.Left) }, }; Func <Option <string>, TypeDef, Parser <ValueToken> > valueInst = null; Parser <TypeDef> typeName = null; // ProcessId parser processId = token( from xs in many1(choice(lower, digit, oneOf("@/[,-_]{}: "))) let r = (new string(xs.ToArray())).Trim() let pid = ProcessId.TryParse(r) from res in pid.Match( Right: x => result(x), Left: ex => failure <ProcessId>($"{ex.Message} '({r})'")) select res); // ProcessName parser processName = token( from o in symbol("\"") from xs in many1(choice(lower, digit, oneOf("@/[,-_]{.}: "))) from c in symbol("\"") let r = (new string(xs.ToArray())).Trim() let n = ProcessName.TryParse(r) from res in n.Match( Right: x => result(x), Left: ex => failure <ProcessName>(ex.Message)) select res); // Attribute parser Func <string, Parser <ValueToken>, Parser <NamedValueToken> > attr = (name, p) => from x in reserved(name) from _ in symbol("=") from v in p select new NamedValueToken(name, v, None); // Type name parser Parser <Type> type = from x in letter from xs in many1(choice(letter, ch('.'), ch('_'))) select Type.GetType(new string(x.Cons(xs).ToArray())); var directive = types.Directive.ValueParser(this).Map(x => (Directive)x); var msgDirective = types.MessageDirective.ValueParser(this).Map(x => (MessageDirective)x); Parser <State <Exception, Option <Directive> > > exceptionDirective = from b in symbol("|") from t in token(type) from a in symbol("->") from d in directive select Strategy.With(d, t); Parser <State <Exception, Option <Directive> > > otherwiseDirective = from b in symbol("|") from t in symbol("_") from a in symbol("->") from d in directive select Strategy.Otherwise(d); Parser <State <Directive, Option <MessageDirective> > > matchMessageDirective = from b in symbol("|") from d in token(directive) from a in symbol("->") from m in token(msgDirective) select Strategy.When(m, d); Parser <State <Directive, Option <MessageDirective> > > otherwiseMsgDirective = from b in symbol("|") from t in symbol("_") from a in symbol("->") from d in token(msgDirective) select Strategy.Otherwise(d); // Strategy exception -> directive parser match = from _ in attempt(reserved("match")) from direx in many(attempt(exceptionDirective)) from other in optional(otherwiseDirective) let dirs = direx.Append(other.AsEnumerable()).ToArray() from ok in dirs.Length > 0 ? result(dirs) : failure <State <Exception, Option <Directive> >[]>("'match' must be followed by at least one clause") select new ValueToken(types.Get("strategy"), Strategy.Match(dirs)); Parser <State <StrategyContext, Unit> > redirectMatch = from direx in many(attempt(matchMessageDirective)) from other in optional(otherwiseMsgDirective) let dirs = direx.Append(other.AsEnumerable()).ToArray() from ok in dirs.Length > 0 ? result(dirs) : failure <State <Directive, Option <MessageDirective> >[]>("'redirect when' must be followed by at least one clause") select Strategy.Redirect(dirs); // Strategy directive -> message-directive matching parser redirect = from n in attempt(reserved("redirect")) from t in either(attempt(symbol(":")), reserved("when")) from r in t == ":" ? from d in token(msgDirective) select Strategy.Redirect(d) : redirectMatch select new ValueToken(types.Get("strategy"), r); // Type name parser typeName = choice(Seq(types.AllInOrder.Map(t => reserved(t.Name).Map(_ => t)))); // cluster.<alias>.<property> parser -- TODO: generalise Parser <ValueToken> clusterVar = attempt( from _ in reserved("cluster") from tup in either( attempt( from d1 in symbol(".") from alias in identifier from d2 in symbol(".") from id in identifier select Tuple(alias, id)), attempt( from d in symbol(".") from id in identifier select Tuple("", id))) from sub in optional(from d2 in symbol(".") from id2 in identifier select id2).Map(x => x.IfNone("value")) from state in getState <ParserState>() // TODO: This can be generalised into an object walking system from v in state.Clusters.Find(tup.Item1).Match( // where an object (in this case the cluster), is in 'scope' Some: cluster => // and recursive walking of the dot operator will find the cluster.Settings.Find(tup.Item2).Match( // value. Some: local => result(local), None: () => failure <ValueToken>($"unknown identifier 'cluster.{tup.Item2}'")), None: () => failure <ValueToken>($"cluster.{tup.Item2} used when a cluster with a node-name attribute set to '{nodeName}' hasn't been defined. Or the cluster called '{nodeName}' exists and is aliased, and you're not providing the variable in the form: cluster.<alias>.<property-name>")) select v ); // Variable of unknown type parser Parser <ValueToken> variable = either( clusterVar, attempt( from id in identifier from state in getState <ParserState>() from v in state.Local(id).Match( Some: v => result(v), None: () => failure <ValueToken>($"unknown identifier '{id}' ")) select v ) ); // Variable of known type parser Func <TypeDef, Parser <ValueToken> > variableOfType = expect => from v in variable from r in v.Type == expect ? result(v) : expect.Convert(v).Match( Some: x => result(x), None: () => failure <ValueToken>($"type mismatch {v.Type} found, expected {expect}") ) select r; Parser <ValueToken> ternary = token( from __ in attempt(reserved("if")) from eb in exprUnknownType from ex in eb.Type == types.Bool ? result(eb) : failure <ValueToken>("ternary expressions must evaluate to a boolean value") from th in reserved("then") from te in exprUnknownType from el in reserved("else") from ee in exprUnknownType select((bool)ex.Value) ? te : ee ); valueUntyped = choice( variable, choice(Seq(types.AllInOrder.Map(typ => attempt(typ.ValueParser(this).Map(val => new ValueToken(typ, typ.Ctor(None, val))))))) ); // Expression term parser Parser <ValueToken> termUnknownType = choice( parens(lazyp(() => exprUnknownType)), ternary, valueUntyped); // Expression parser exprUnknownType = buildExpressionParser(table.Reverse().ToArray(), termUnknownType); // Variable declaration parser valueDef = from typ in either( attempt(reserved("let")).Map(x => Option <TypeDef> .None), typeName.Map(Option <TypeDef> .Some) ) from arr in optional(symbol("[]")) from _ in arr.IsSome && typ.IsNone ? failure <Unit>("when declaring an array you must specify the type, you can't use 'let'") : result <Unit>(unit) from id in identifier.label("identifier") from alias in optional( from a_ in reserved("as") from nm in identifier select nm) from __ in symbol(":") from v in arr.IsSome ? either( attempt(valueInst(alias, TypeDef.Map(() => typ.IfNone(TypeDef.Unknown)))), valueInst(alias, TypeDef.Array(() => typ.IfNone(TypeDef.Unknown)))) : typ.Map(t => expr(alias, t)) .IfNone(() => exprUnknownType) from nv in result(new NamedValueToken(id, v, alias)) from state in getState <ParserState>() from res in state.LocalExists(id) ? failure <ParserState>($"A value with the name '{id}' already declared") : result(state.AddLocal(id, v)) from ___ in setState(res) select nv; // Value or variable parser valueInst = (alias, typ) => either(variableOfType(typ), typ.ValueParser(this).Map(value => new ValueToken(typ, typ.Ctor(alias, value)))); // Expression term parser term = (alias, expected) => choice( parens(lazyp(() => expr(alias, expected))), valueInst(alias, expected), from val in exprUnknownType from res in val.Type == expected ? result(val) : failure <ValueToken>($"expression must evaluate to {expected}, it actually evaluates to {val.Type}") select res ); // Expression parser expr = (alias, expected) => buildExpressionParser(table, term(alias, expected)); // Parses a named argument: name = value namedArgument = (settingName, spec) => attempt(token(attr(spec.Name, expr(None, spec.Type())))); // Parses a single non-named argument argument = (settingName, spec) => attempt(token(expr(None, spec.Type()).Map(x => new NamedValueToken(spec.Name, x, None)))); // Parses many arguments, wrapped in ( ) argumentMany = (settingName, spec) => from a in commaSep1(choice(Seq(spec.Map(arg => namedArgument(settingName, arg))))) from r in a.Count == spec.Length ? result(a) : failure <Seq <NamedValueToken> >("Invalid arguments for " + settingName) select r; // Parses the arguments for a setting arguments = (settingName, spec) => spec.Length == 0 ? failure <Seq <NamedValueToken> >("Invalid arguments spec, has zero arguments") : spec.Length == 1 ? from a in argument(settingName, spec.Head()) select Seq1(a) : argumentMany(settingName, spec); // Declare the global type var globalType = new TypeDef("global", (_, x) => x, typeof(Lst <NamedValueToken>), nodeName, 0); // Global namespace parser = from ws in whiteSpace from __ in setState(ParserState.Empty) from ss in globalType.ValueParser(this) select(Lst <NamedValueToken>) ss; }
public InitializeStrategyCommand(Strategy strategy, DateTime from, DateTime to) { Strategy = strategy; FromDate = from; ToDate = to; }
// Parse the pairs data from PT to our own common data structure. private List <DCALogData> ParsePairsData(dynamic pairsData, bool processBuyStrategies) { List <DCALogData> pairs = new List <DCALogData>(); foreach (var pair in pairsData) { DCALogData dcaLogData = new DCALogData(); dcaLogData.Amount = pair.totalAmount; dcaLogData.BoughtTimes = pair.boughtTimes; dcaLogData.Market = pair.market; dcaLogData.ProfitPercent = pair.profit; dcaLogData.AverageBuyPrice = pair.avgPrice; dcaLogData.TotalCost = pair.totalCost; dcaLogData.BuyTriggerPercent = pair.buyProfit; dcaLogData.CurrentLowBBValue = pair.bbLow == null ? 0 : pair.bbLow; dcaLogData.CurrentHighBBValue = pair.highBb == null ? 0 : pair.highBb; dcaLogData.BBTrigger = pair.bbTrigger == null ? 0 : pair.bbTrigger; dcaLogData.CurrentPrice = pair.currentPrice; dcaLogData.SellTrigger = pair.triggerValue == null ? 0 : pair.triggerValue; dcaLogData.PercChange = pair.percChange; dcaLogData.Leverage = pair.leverage == null ? 0 : pair.leverage; dcaLogData.BuyStrategy = pair.buyStrategy == null ? "" : pair.buyStrategy; dcaLogData.SellStrategy = pair.sellStrategy == null ? "" : pair.sellStrategy; dcaLogData.IsTrailing = false; if (pair.buyStrategies != null && processBuyStrategies) { foreach (var bs in pair.buyStrategies) { Strategy buyStrategy = new Strategy(); buyStrategy.Type = bs.type; buyStrategy.Name = bs.name; buyStrategy.EntryValue = bs.entryValue; buyStrategy.EntryValueLimit = bs.entryValueLimit; buyStrategy.TriggerValue = bs.triggerValue; buyStrategy.CurrentValue = bs.currentValue; buyStrategy.CurrentValuePercentage = bs.currentValuePercentage; buyStrategy.Decimals = bs.decimals; buyStrategy.IsTrailing = ((string)bs.positive).IndexOf("trailing", StringComparison.InvariantCultureIgnoreCase) > -1; buyStrategy.IsTrue = ((string)bs.positive).IndexOf("true", StringComparison.InvariantCultureIgnoreCase) > -1; dcaLogData.BuyStrategies.Add(buyStrategy); } } if (pair.sellStrategies != null) { foreach (var ss in pair.sellStrategies) { Strategy sellStrategy = new Strategy(); sellStrategy.Type = ss.type; sellStrategy.Name = ss.name; sellStrategy.EntryValue = ss.entryValue; sellStrategy.EntryValueLimit = ss.entryValueLimit; sellStrategy.TriggerValue = ss.triggerValue; sellStrategy.CurrentValue = ss.currentValue; sellStrategy.CurrentValuePercentage = ss.currentValuePercentage; sellStrategy.Decimals = ss.decimals; sellStrategy.IsTrailing = ((string)ss.positive).IndexOf("trailing", StringComparison.InvariantCultureIgnoreCase) > -1; sellStrategy.IsTrue = ((string)ss.positive).IndexOf("true", StringComparison.InvariantCultureIgnoreCase) > -1; dcaLogData.SellStrategies.Add(sellStrategy); // Find the target percentage gain to sell. if (sellStrategy.Name.Contains("GAIN", StringComparison.InvariantCultureIgnoreCase)) { if (!dcaLogData.TargetGainValue.HasValue || dcaLogData.TargetGainValue.Value > sellStrategy.EntryValue) { // Set the target sell percentage dcaLogData.TargetGainValue = sellStrategy.EntryValue; } } } } // Calculate current value dcaLogData.CurrentValue = dcaLogData.CurrentPrice * dcaLogData.Amount; // Convert Unix Timestamp to Datetime System.DateTime rdldDateTime = new DateTime(1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc); rdldDateTime = rdldDateTime.AddSeconds((double)pair.firstBoughtDate).ToUniversalTime(); // Profit Trailer bought times are saved in UTC if (pair.firstBoughtDate > 0) { DateTimeOffset ptFirstBoughtDate = DateTimeOffset.Parse(rdldDateTime.Year.ToString() + "-" + rdldDateTime.Month.ToString("00") + "-" + rdldDateTime.Day.ToString("00") + "T" + rdldDateTime.Hour.ToString("00") + ":" + rdldDateTime.Minute.ToString("00") + ":" + rdldDateTime.Second.ToString("00"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal); // Convert UTC bought time to local offset time ptFirstBoughtDate = ptFirstBoughtDate.ToOffset(OffsetTimeSpan); dcaLogData.FirstBoughtDate = ptFirstBoughtDate.DateTime; } else { dcaLogData.FirstBoughtDate = Constants.confMinDate; } _dcaLog.Add(dcaLogData); } return(pairs); }
public Rewriter(Strategy strategy) { CurrentStrategy = strategy; }
TypeDef BuildStrategySpec(Types types, IEnumerable <FuncSpec> strategyFuncs) { TypeDef strategy = null; Func <Lst <NamedValueToken>, Lst <State <StrategyContext, Unit> > > compose = items => items.Map(x => (State <StrategyContext, Unit>)x.Value.Value); var oneForOne = FuncSpec.Property("one-for-one", () => strategy, () => strategy, value => Strategy.OneForOne((State <StrategyContext, Unit>)value)); var allForOne = FuncSpec.Property("all-for-one", () => strategy, () => strategy, value => Strategy.AllForOne((State <StrategyContext, Unit>)value)); var always = FuncSpec.Property("always", () => strategy, () => types.Directive, value => Strategy.Always((Directive)value)); var pause = FuncSpec.Property("pause", () => strategy, () => types.Time, value => Strategy.Pause((Time)value)); var retries1 = FuncSpec.Property("retries", () => strategy, () => types.Int, value => Strategy.Retries((int)value)); var retries2 = FuncSpec.Attrs( "retries", () => strategy, locals => Strategy.Retries((int)locals["count"], (Time)locals["duration"]), new FieldSpec("count", () => types.Int), new FieldSpec("duration", () => types.Time) ); var backoff1 = FuncSpec.Attrs( "backoff", () => strategy, locals => Strategy.Backoff((Time)locals["min"], (Time)locals["max"], (Time)locals["step"]), new FieldSpec("min", () => types.Time), new FieldSpec("max", () => types.Time), new FieldSpec("step", () => types.Time) ); var backoff2 = FuncSpec.Attrs( "backoff", () => strategy, locals => Strategy.Backoff((Time)locals["min"], (Time)locals["max"], (double)locals["scalar"]), new FieldSpec("min", () => types.Time), new FieldSpec("max", () => types.Time), new FieldSpec("scalar", () => types.Double) ); var backoff3 = FuncSpec.Property("backoff", () => strategy, () => types.Time, value => Strategy.Backoff((Time)value)); // match // | exception -> directive // | _ -> directive var match = FuncSpec.Special("match", () => strategy); // redirect when // | directive -> message-directive // | _ -> message-directive var redirect = FuncSpec.Special("redirect", () => strategy); strategy = new TypeDef( "strategy", typeof(State <StrategyContext, Unit>), (_, s) => Strategy.Compose(compose((Lst <NamedValueToken>)s).ToArray().ToArray()), 20, new[] { oneForOne, allForOne, always, pause, retries1, retries2, backoff1, backoff2, backoff3, match, redirect }.Append(strategyFuncs).ToArray() ); return(strategy); }
/// <summary> /// Constructor: Creates a tree for a given strategy /// </summary> /// <param name="strategy">reference strategy. /// </param> public Tree(Strategy strategy) { this._parentStrategy = strategy; }
// Constructor public Context(Strategy strategy) { this._strategy = strategy; }
/// <summary> /// Function: recursive helper function for cloning process. /// </summary> /// <param name="initialDate">Clone's initialDate</param> /// <param name="finalDate">Clone's finalDate</param> /// <param name="clones">internal table of previously cloned base ids and respective cloned strategies</param> /// <param name="initial_values">internal table of initial values for the new cloned strategies</param> /// <param name="simulated">true if the strategy is simulated and not persistent</param> private Tree Clone_Internal(DateTime initialDate, DateTime finalDate, Dictionary <int, Strategy> clones, Dictionary <int, double> initial_values, bool simulated) { Dictionary <int, Strategy> clones_internal = new Dictionary <int, Strategy>(); foreach (Strategy strat in _strategyDB.Values.ToList()) { Tree tree_clone = strat.Tree.Clone_Internal(initialDate, finalDate, clones, initial_values, simulated); if (tree_clone != null) { if (!clones.ContainsKey(strat.ID)) { clones.Add(strat.ID, tree_clone.Strategy); } clones_internal.Add(strat.ID, tree_clone.Strategy); } } foreach (Strategy strategy in _strategyDB.Values.ToList()) { if (strategy.Portfolio == null) { if (!clones.ContainsKey(strategy.ID)) { Strategy subclone = strategy.Clone(null, initialDate, finalDate, clones, simulated); if (!clones.ContainsKey(strategy.ID)) { clones.Add(strategy.ID, subclone); } clones_internal.Add(strategy.ID, subclone); initial_values.Add(subclone.ID, strategy.GetTimeSeries(TimeSeriesType.Last).Values[0]); } else { clones_internal.Add(strategy.ID, clones[strategy.ID]); } } } if (_parentStrategy.Portfolio != null) { Portfolio portfolioClone = _parentStrategy.Portfolio.Clone(simulated); foreach (int[] ids in _parentStrategy.Portfolio.ReserveIds.ToList()) { Currency ccy = Currency.FindCurrency(ids[0]); Instrument longReserve = Instrument.FindInstrument(ids[1]); Instrument shortReserve = Instrument.FindInstrument(ids[2]); portfolioClone.AddReserve(ccy, longReserve.InstrumentType == InstrumentType.Strategy ? clones[longReserve.ID] : longReserve, shortReserve.InstrumentType == InstrumentType.Strategy ? clones[shortReserve.ID] : shortReserve); } Strategy strategyClone = _parentStrategy.Clone(portfolioClone, initialDate, finalDate, clones, simulated); if (!clones.ContainsKey(_parentStrategy.ID)) { clones.Add(_parentStrategy.ID, strategyClone); } initial_values.Add(strategyClone.ID, _parentStrategy.GetAUM(DateTime.Now, TimeSeriesType.Last)); Tree clone = strategyClone.Tree; foreach (Strategy st in clones_internal.Values.ToList()) { if (st.Portfolio != null) { st.Portfolio.ParentPortfolio = clone.Strategy.Portfolio; } clone.AddSubStrategy(st); } return(clone); } return(null); }
public static string GenerateBotName(string nameFormula, string symbol, Strategy strategy) { return(nameFormula .Replace("{pair}", symbol) .Replace("{strategy}", strategy.ToString())); }
public override void AddStrategy(Strategy strategy) { switch (((CostBudgetBackupSetStrategyName)strategy.Name)) { case CostBudgetBackupSetStrategyName.CostBudgetBackupSetCode: strategy.RelationFieldName = "CostBudgetBackupSetCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.CostBudgetBackupCode: strategy.RelationFieldName = "CostBudgetBackupCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.CostBudgetSetCode: strategy.RelationFieldName = "CostBudgetSetCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.ProjectCode: strategy.RelationFieldName = "ProjectCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.CostBudgetSetName: strategy.RelationFieldName = "CostBudgetSetName"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.CostBudgetSetNameLike: strategy.RelationFieldName = "CostBudgetSetName"; strategy.Type = StrategyType.StringLike; strategy.SetParameter(0, "%" + strategy.GetParameter(0) + "%"); break; case CostBudgetBackupSetStrategyName.UnitCode: strategy.RelationFieldName = "UnitCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.GroupCode: strategy.RelationFieldName = "GroupCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.CostCode: strategy.RelationFieldName = "CostCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.PBSType: strategy.RelationFieldName = "PBSType"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.PBSCode: strategy.RelationFieldName = "PBSCode"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.BackupPerson: strategy.RelationFieldName = "BackupPerson"; strategy.Type = StrategyType.StringEqual; break; case CostBudgetBackupSetStrategyName.BackupDateRange: strategy.RelationFieldName = "BackupDate"; strategy.Type = StrategyType.DateTimeRangeOnlyDate; break; default: strategy.Type = StrategyType.Other; break; } base.AddStrategy(strategy); }
/// <summary> /// Initializes a new instance of the <see cref="StrategyParam"/>. /// </summary> /// <param name="strategy">Strategy.</param> /// <param name="id">Parameter identifier.</param> /// <param name="name">Parameter name.</param> public StrategyParam(Strategy strategy, string id, string name) : base(strategy, id, name, typeof(T), default) { }
/// <summary> /// Initializes a new instance of the <see cref="StrategyParam"/>. /// </summary> /// <param name="strategy">Strategy.</param> /// <param name="name">Parameter name.</param> public StrategyParam(Strategy strategy, string name) : base(strategy, name, name, typeof(T)) { }
/// <summary> /// Initializes a new instance of the <see cref="StrategyParam"/>. /// </summary> /// <param name="strategy">Strategy.</param> /// <param name="id">Parameter identifier.</param> /// <param name="name">Parameter name.</param> /// <param name="initialValue">The initial value.</param> public StrategyParam(Strategy strategy, string id, string name, T initialValue) : base(strategy, id, name, typeof(T), initialValue) { }
public override int GetHashCode() { int hash = 1; if (TradeId.Length != 0) { hash ^= TradeId.GetHashCode(); } if (ExchangeOrderId.Length != 0) { hash ^= ExchangeOrderId.GetHashCode(); } if (System.Length != 0) { hash ^= System.GetHashCode(); } if (Counterparty.Length != 0) { hash ^= Counterparty.GetHashCode(); } if (PortfolioId.Length != 0) { hash ^= PortfolioId.GetHashCode(); } if (Volume != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Volume); } if (InstrumentId.Length != 0) { hash ^= InstrumentId.GetHashCode(); } if (Price != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Price); } if (Currency.Length != 0) { hash ^= Currency.GetHashCode(); } if (timestamp_ != null) { hash ^= Timestamp.GetHashCode(); } hash ^= AdditionalData.GetHashCode(); if (SystemTradeId.Length != 0) { hash ^= SystemTradeId.GetHashCode(); } if (UniqueTradeId.Length != 0) { hash ^= UniqueTradeId.GetHashCode(); } if (Desk.Length != 0) { hash ^= Desk.GetHashCode(); } if (ExchangeTradeId.Length != 0) { hash ^= ExchangeTradeId.GetHashCode(); } if (MarketTrade != false) { hash ^= MarketTrade.GetHashCode(); } if (AlgoId.Length != 0) { hash ^= AlgoId.GetHashCode(); } if (Strategy.Length != 0) { hash ^= Strategy.GetHashCode(); } if (Owner.Length != 0) { hash ^= Owner.GetHashCode(); } if (ClearerAccount.Length != 0) { hash ^= ClearerAccount.GetHashCode(); } if (Depot.Length != 0) { hash ^= Depot.GetHashCode(); } if (Safekeeping.Length != 0) { hash ^= Safekeeping.GetHashCode(); } if (Deleted != false) { hash ^= Deleted.GetHashCode(); } if (FundingCurrency.Length != 0) { hash ^= FundingCurrency.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public virtual OptimizationParameterSet Optimize(Strategy strategy, OptimizationUniverse universe = null) { return(null); }
private By(params By[] locators) { _strategy = Strategy.Any; _value = locators; }
private void Optimize(Strategy strategy, InstrumentList instruments, OptimizationUniverse universe, int nFrameworks, int nStrategies) { throw new NotImplementedException(); }
public InternalOrders(Strategy strategy, TradeDirection direction) { this.strategy = strategy; this.direction = direction; }
/// <summary> /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>. /// </summary> /// <returns> /// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>. /// </returns> public override string ToString() { return(string.Format("Ур{0} Пер{1} {2} {3} ", Level, MinResalesCount, Strategy.GetDescription(), Price)); }
private By(Strategy strategy, string value) { _strategy = strategy; _value = value; }
private void SetStrategy(ref Strategy stratToSet, Strategy strat) { stratToSet = strat; }
public override void Save(SettingsStorage storage) { Strategy?.Save(storage); base.Save(storage); }