/// <summary> /// Returns time of next specified value Usage: AudioSource.PlayScheduled(AtNext(Beat.TickValue.Quarter)) /// </summary> /// <param name="beatTickValue">TickValue for which to get time of next</param> /// <returns>Time of next specified value</returns> public double AtNext(TickValue beatTickValue) { switch (beatTickValue) { case TickValue.ThirtySecond: return(AtNextThirtySecond()); case TickValue.SixteenthTriplet: return(AtNextSixteenthTriplet()); case TickValue.Sixteenth: return(AtNextSixteenth()); case TickValue.EighthTriplet: return(AtNextEighthTriplet()); case TickValue.Eighth: return(AtNextEighth()); case TickValue.QuarterTriplet: return(AtNextQuarterTriplet()); case TickValue.Quarter: return(AtNextQuarter()); case TickValue.Half: return(AtNextHalf()); case TickValue.Measure: return(AtNextMeasure()); default: return(AtNextBeat()); } }
/// <summary> /// Print a TicketValue /// </summary> /// <param name="value">The value</param> public static void Print(this TickValue value) { Console.WriteLine( string.Format("{0,-25} {1,-25} {2,-30} {3,-25}", "Cash", "Food", "Resources", "Science Points")); Console.WriteLine( string.Format( "{0,-15} {1,10:G4} {2,-15} {3,10:G4} {4,-20} {5,10:G4} {6,-15} {7,10:G4}", "Income", value.ProducedCash, "Food Produced", value.ProducedFood, "Iron Mined", value.ProducedIron, "Military", 0)); Console.WriteLine( string.Format( "{0,-15} {1,10:G4} {2,-15} {3,10:G4} {4,-20} {5,10:G4} {6,-15} {7,10:G4}", "Units", -value.Units, "Food Consumed", value.ProducedFood, "Iron Decayed", value.DecayedIron, "Welfare", 0)); Console.WriteLine( string.Format( "{0,-15} {1,10:G4} {2,-15} {3,10:G4} {4,-20} {5,10:G4} {6,-15} {7,10:G4}", "Buildings", -value.Buildings, "Food Decayed", value.DecayedFood, "Plutonium Mined", value.ProducedEnergy, "Economy", 0)); Console.WriteLine( string.Format( "{0,-15} {1,10:G4} {2,-15} {3,10:G4} {4,-20} {5,10:G4} {6,-15} {7,10:G4}", "Bureaucracy", -value.DecayedCash, "Net Flow", value.ProducedFood, "Plutonium Decayed", value.DecayedEnergy, "Construction", 0)); Console.WriteLine( string.Format( "{0,-15} {1,10} {2,-15} {3,10} {4,-20} {5,10:G4} {6,-15} {7,10:G4}", string.Empty, string.Empty, string.Empty, string.Empty, "Mana Mined", 0, "Resources", 0)); }
public Args(TickValue beatVal, double beatTime, double nextBeatTime, TickMask <bool> beatTickMask) { BeatVal = beatVal; BeatTime = beatTime; NextBeatTime = nextBeatTime; TickMask = beatTickMask; }
/// <summary> /// Helper fucntions for timing things like tweens & animations to the beat clock /// </summary> /// <param name="beatTickValue"></param> /// <returns></returns> public float LengthOf(TickValue beatTickValue) { switch (beatTickValue) { case TickValue.ThirtySecond: return(ThirtySecondLength()); case TickValue.SixteenthTriplet: return(SixteenthTripletLength()); case TickValue.Sixteenth: return(SixteenthLength()); case TickValue.EighthTriplet: return(EighthTripletLength()); case TickValue.Eighth: return(EighthLength()); case TickValue.QuarterTriplet: return(QuarterTripletLength()); case TickValue.Quarter: return(QuarterLength()); case TickValue.Half: return(HalfLength()); case TickValue.Measure: return(MeasureLength()); default: return(BeatLength()); } }
/// <summary> /// Imports quotes to storage. /// </summary> /// <param name="ticks">Ticks, which should be imported.</param> /// <param name="level2">Ignore depth of level2, if false.</param> /// <param name="overwriteTickChainsWithEqualTime"></param> /// <param name="rebuild">The method rebuilds all bars, if true.</param> public void Import(IEnumerable <Quote> ticks, bool level2, bool overwriteTickChainsWithEqualTime, bool rebuild) { var groupdeBySymbols = ticks.GroupBy(t => t.Symbol); foreach (var symbolsTicks in groupdeBySymbols) { var groupedTicksValues = symbolsTicks.Select(qt => { var tl2Bids = qt.Bids.Select(qa => new FeedLevel2Record { Price = (decimal)qa.Price, Type = FxPriceType.Bid, Volume = qa.Volume }); var tl2Asks = qt.Asks.Select(qa => new FeedLevel2Record { Price = (decimal)qa.Price, Type = FxPriceType.Ask, Volume = qa.Volume }); var ret = new TickValue(qt.CreatingTime, tl2Asks.Concat(tl2Bids)); return(ret); }); var provider = this.GetOrCreateHistoryManager(symbolsTicks.Key); provider.ImportTicks(groupedTicksValues, symbolsTicks.Key, level2, true, overwriteTickChainsWithEqualTime ? TicksImportRules.Replace : TicksImportRules.Append, null); if (rebuild) { } } }
public T this[TickValue i] { get { return(_beatMaskArr[(int)i]); } set { _beatMaskArr[(int)i] = value; } }
public static double ExitPrice(this TickValue tick, BuyStyle style) { if (style == BuyStyle.Long) { return(tick.BidPrice); } else { return(tick.AskPrice); } }
public static double EntryPrice(BuyStyle style, TickValue tick) { if (style == BuyStyle.Long) { return(tick.AskPrice); } else { return(tick.BidPrice); } }
public static int CalculateQuantity(BuyStyle style, TickValue from, double budget) { if (style == BuyStyle.Long) { return(CalculateQuantity(BuyStyle.Long, from.AskPrice, budget)); } else { //short return(CalculateQuantity(BuyStyle.Short, from.BidPrice, budget)); } }
public static Trade CalculateTrade(BuyStyle style, long fromTime, TickValue from, long toTime, TickValue to, double budget) { if (style == BuyStyle.Long) { return(CalculateTrade(BuyStyle.Long, from.AskPrice, to.BidPrice, fromTime, toTime, budget)); } else { //short return(CalculateTrade(BuyStyle.Short, from.BidPrice, to.AskPrice, fromTime, toTime, budget)); } }
public static (double Profit, int Quantity) CalculateProfit(BuyStyle style, TickValue from, double to, double budget) { if (style == BuyStyle.Long) { return(CalculateProfit(BuyStyle.Long, from.AskPrice, to, budget)); } else { //short return(CalculateProfit(BuyStyle.Short, from.BidPrice, to, budget)); } }
public static (float Profit, int Quantity) CalculateProfit(BuyStyle style, TickValue from, float to, int quantity) { if (style == BuyStyle.Long) { return(CalculateProfit(BuyStyle.Long, (float)from.AskPrice, to, quantity)); } else { //short return(CalculateProfit(BuyStyle.Short, (float)from.BidPrice, to, quantity)); } }
/// <param name="style">The trade style</param> /// <param name="price">Price of the stock</param> /// <param name="quantity">Absolute quantity</param> /// <param name="profitDollar">Profit in dollars, can be negative if loss planned</param> /// <returns></returns> public static double LimitAtProfit(BuyStyle style, TickValue tick, int quantity, double profitDollar) { if (quantity == 0) { throw new ArgumentOutOfRangeException(nameof(quantity)); } quantity = Math.Abs(quantity); //161*(1+0.05/100) var mod = style == BuyStyle.Long ? 1 : -1; var balance = (style == BuyStyle.Long ? tick.AskPrice : tick.BidPrice) * quantity; var targetbalance = balance + mod * profitDollar; var targetPrice = targetbalance / quantity; return(Math.Round(targetPrice, 2)); }
public Quote ToQuote(string symbol, TickValue tick, int depth) { var creatingTime = tick.Time; var bids = tick.Level2 .Where(o => o.Type == FxPriceType.Bid) .Select(o => new QuoteEntry((double)o.Price, (double)o.Volume)) .ToArray(); var asks = tick.Level2 .Where(o => o.Type == FxPriceType.Ask) .Select(o => new QuoteEntry((double)o.Price, (double)o.Volume)) .ToArray(); Array.Sort(bids, BidComparator); Array.Sort(asks, AskComparator); return(new Quote(symbol, creatingTime, bids.Take(depth).ToArray(), asks.Take(depth).ToArray())); }
/// <summary> /// Sync the execution of a particular callback to a specified beat a specified number of times /// </summary> /// <param name="callback">Function to call</param> /// <param name="beatTickValue">Beat value at which function will be called</param> /// <param name="repetitions">Number of times function will be called</param> /// <returns></returns> IEnumerator YieldForSyncRepeating(System.Action callback, TickValue beatTickValue, int repetitions) { Debug.Log("Yield for sync TickMask: " + TickMask[beatTickValue]); int startCount = _tickCounter + _measureCount * _ticksPerMeasure; bool isStartNote = true; bool waiting = true; int timesRun = 0; int tickOfLastRun = 0; while (waiting) { isStartNote = isStartNote && startCount == _tickCounter + _measureCount * _ticksPerMeasure; if (isStartNote) { yield return(false); } isStartNote = false; if ((beatTickValue == TickValue.ThirtySecond || TickMask[beatTickValue]) && (tickOfLastRun != _tickCounter + _measureCount * _ticksPerMeasure)) { if (repetitions <= timesRun) { waiting = false; } else { callback(); tickOfLastRun = _tickCounter + _measureCount * _ticksPerMeasure; timesRun++; yield return(false); } } else { yield return(false); } } }
/// <summary> /// Sync the execution of a particular callback to a specified beat a specified number of times /// </summary> /// <param name="callback">Function to call at next beatTickValue</param> /// <param name="beatTickValue">Beat value at which function will be called</param> /// <param name="repetitions">Number of times function will be called</param> public void SyncFunction(System.Action callback, TickValue beatTickValue, int repetitions) { StartCoroutine(YieldForSyncRepeating(callback, beatTickValue, repetitions)); }
/// <summary> /// Sync the execution of a function to the next specified beat, optionally add a number repetitions /// </summary> /// <param name="callback">Function to call at next beatTickValue</param> /// <param name="beatTickValue">Beat value at which function will be called (Default is measure / downbeat)</param> IEnumerator YieldForSync(System.Action callback, TickValue beatTickValue) { return(YieldForSyncRepeating(callback, beatTickValue, 1)); }
//Note - these sync functions do not work properly /// <summary> /// Sync the execution of a function to the next specified beat, optionally add a number repetitions /// </summary> /// <param name="callback">Function to call at next beatTickValue</param> /// <param name="beatTickValue">Beat value at which function will be called (Default is measure / downbeat)</param> public void SyncFunction(System.Action callback, TickValue beatTickValue = TickValue.Measure) { StartCoroutine(YieldForSync(callback, beatTickValue)); }
public static (double Profit, int Quantity) CalculateProfit(BuyStyle style, double from, TickValue to, int quantity) { if (style == BuyStyle.Long) { return(CalculateProfit(BuyStyle.Long, from, to.BidPrice, quantity)); } else { //short return(CalculateProfit(BuyStyle.Short, from, to.AskPrice, quantity)); } }
/// <summary> /// Imports quotes to storage. /// </summary> /// <param name="ticks">Ticks, which should be imported.</param> /// <param name="level2">Ignore depth of level2, if false.</param> /// <param name="overwriteTickChainsWithEqualTime"></param> /// <param name="rebuild">The method rebuilds all bars, if true.</param> public void Import(IEnumerable<Quote> ticks, bool level2, bool overwriteTickChainsWithEqualTime, bool rebuild) { var groupdeBySymbols = ticks.GroupBy(t => t.Symbol); foreach (var symbolsTicks in groupdeBySymbols) { var groupedTicksValues = symbolsTicks.Select(qt => { var tl2Bids = qt.Bids.Select(qa => new FeedLevel2Record { Price = (decimal)qa.Price, Type = FxPriceType.Bid, Volume = qa.Volume }); var tl2Asks = qt.Asks.Select(qa => new FeedLevel2Record { Price = (decimal)qa.Price, Type = FxPriceType.Ask, Volume = qa.Volume }); var ret = new TickValue(qt.CreatingTime, tl2Asks.Concat(tl2Bids)); return ret; }); var provider = this.GetOrCreateHistoryManager(symbolsTicks.Key); provider.ImportTicks(groupedTicksValues, symbolsTicks.Key, level2, true, overwriteTickChainsWithEqualTime ? TicksImportRules.Replace : TicksImportRules.Append, null); if (rebuild) { } } }
public static (float Profit, int Quantity) CalculateProfit(BuyStyle style, float from, TickValue to, float budget) { if (style == BuyStyle.Long) { return(CalculateProfit(BuyStyle.Long, from, (float)to.BidPrice, budget)); } else { //short return(CalculateProfit(BuyStyle.Short, from, (float)to.AskPrice, budget)); } }
public Quote ToQuote(string symbol, TickValue tick, int depth) { var creatingTime = tick.Time; var bids = tick.Level2 .Where(o => o.Type == FxPriceType.Bid) .Select(o => new QuoteEntry((double)o.Price, (double)o.Volume)) .ToArray(); var asks = tick.Level2 .Where(o => o.Type == FxPriceType.Ask) .Select(o => new QuoteEntry((double)o.Price, (double)o.Volume)) .ToArray(); Array.Sort(bids, BidComparator); Array.Sort(asks, AskComparator); return new Quote(symbol, creatingTime, bids.Take(depth).ToArray(), asks.Take(depth).ToArray()); }
public override string ToString() { return(TickValue.ToString() + "," + RandomValue.ToString()); }