public override bool OnIntervalClose() { if (Count == 1) { highestHigh = Bars.High[0]; lowestLow = Bars.Low[0]; } else { // this goes higher while.. highestHigh = Math.Max(highestHigh, Bars.High[0]); // lowest goes lower lowestLow = Math.Min(Bars.Low[0], lowestLow); // when the high rises high enough it becomes a new potential pivot. if (Bars.High[0] > Formula.Highest(Bars.High, 3, 1) && Bars.High[0] - lowestLow > minimumMove) { highestHigh = Bars.High[0]; lowestLow = Bars.Low[0]; } // when low drops below highest far enough, it's a new pivot if (this[0] != highestHigh && highestHigh - Bars.Low[0] > minimumMove) { this[0] = highestHigh; pivots.Add((int)this[0]); } } return(true); }
public void it_adds() { var expected = 4; var actual = Integers.Add(2, 2); actual.Should().Be(expected); }
//methods public void InputNumbers() { //take inputs until non-number input given bool properInput = true; while (properInput) { double input; Console.WriteLine("Write whole number or decimal. Non-number input exits input."); if (double.TryParse(Console.ReadLine(), out input)) { //Check for whole number if ((input % 1) == 0) { //add to int list Integers.Add(Convert.ToInt32(input)); } else { //add to double list Doubles.Add(input); } } else { properInput = false; } } }
protected override void VisitChildren(PtNode node) { var children = reflect.Or(node).ToList(); if (children.Count == 0) { for (var i = node.Span.Start; i < node.Span.Next; ++i) { Set.Add(i); } if (node is PtArguments || node is PtParameters || node is PtLambdaParameters || node is PtLambdaTypeParameters || node is PtFields || node is PtMethods || node is PtUnit) { } else { var text = node.Span.ToString(); Debug.Assert(!string.IsNullOrWhiteSpace(text)); Debug.Assert(text != "(-)"); //System.Console.WriteLine($"{text}"); } } base.VisitChildren(node); }
public override bool OnIntervalClose() { int newCode = lrGraph.Code; // switch( newCode) { // case 1: newCode = 0; break; // case 6: newCode = 7; break; // } stretch[0] = newCode; if (newCode != lastCode) { // Got a code change, close out the previous one. if (lastCodes.Count > 2) { int combinedCode = lastCodes[1] * 8 + lastCodes[0]; CodeStats codeStats; if (codes.TryGetValue(combinedCode, out codeStats)) { codeStats.Count++; codeStats.CountBars += (Bars.CurrentBar - lastBar); codeStats.ProfitLoss += (Bars.Close[0] - lastPrices[0]); codes[combinedCode] = codeStats; } else { codeStats.Count = 1; codeStats.CountBars = 1; codeStats.ProfitLoss = 0; codes[combinedCode] = codeStats; } } // Alright start the new code. lastCodes.Add(newCode); lastPrices.Add(Bars.Close[0]); if (lastCodes.Count > 2) { int combinedCode = lastCodes[1] * 8 + lastCodes[0]; TradeDecision(combinedCode); } lastBar = Bars.CurrentBar; lastCode = newCode; } else { } // switch( lrGraph.Code) { // case 0: TradeSignal.GoShort(); break; // case 1: TradeSignal.GoShort(); break; // case 2: TradeSignal.GoShort(); break; // case 3: TradeSignal.GoShort(); break; // case 4: TradeSignal.GoLong(); break; // case 5: TradeSignal.GoLong(); break; // case 6: TradeSignal.GoLong(); break; // case 7: TradeSignal.GoLong(); break; // } return(true); }
private void BeforeIntervalClose() { if (price.BarCount > 1 && avgPrice.Count > 1) { int currPrice = (int)(price[0] - avgPrice[0]); int lastPrice = (int)(price[1] - avgPrice[1]); int change = currPrice - lastPrice; if (IsTrace) { Log.Trace(Name + ": price[0]=" + price[0] + ",avgPrice[0]=" + avgPrice[0] + ",price[1]=" + price[1] + ",avgPrice[1]=" + avgPrice[1]); } if (change > 0) { gain.Add(change); loss.Add(0); Log.Debug("gain.Add(" + change + ")"); Log.Debug("loss.Add(0)"); } else { gain.Add(0); loss.Add(-change); Log.Debug("gain.Add(0)"); Log.Debug("loss.Add(" + (-change) + ")"); } } else { gain.Add(0); loss.Add(0); if (IsTrace) { Log.Trace("gain.Add(0)"); } if (IsTrace) { Log.Trace("loss.Add(0)"); } } }
private void CalcFTT(Bars bars) { if (highMaxVolume.Count == 0) { highMaxVolume.Add(0); } else { highMaxVolume.Add(highMaxVolume[0]); } if (lowMaxVolume.Count == 0) { lowMaxVolume.Add(0); } else { lowMaxVolume.Add(lowMaxVolume[0]); } if (bars.High[0] > fttHighestHigh && bars.High[0] > bars.High[1]) { if (bars.Volume[0] > highMaxVolume[0]) { highMaxVolume[0] = bars.Volume[0]; } fttHighestHigh = bars.High[0]; } if (bars.Low[0] < fttLowestLow && bars.Low[0] < bars.Low[1]) { if (bars.Volume[0] > lowMaxVolume[0]) { lowMaxVolume[0] = bars.Volume[0]; log.Debug("Low Max Volume Set to " + lowMaxVolume[0]); } fttLowestLow = bars.Low[0]; } }
SimEvents StorePutter(Store <int> store, int putCount, int timeout) { Debug.Assert(putCount >= 0); Debug.Assert(timeout >= 0); for (var i = 0; i < putCount; ++i) { Integers.Add(i); yield return(store.Put(i)); if (timeout > 0) { yield return(Env.Timeout(timeout)); } } }
/// <summary> /// Initializes this instance, registers all Integers and Doubles /// </summary> protected void Init() { var t = GetType(); if (MetricsExtensions.CachedMetricsDefinitions.ContainsKey(t.FullName)) { MetricsExtensions.CachedMetricsDefinitions[t.FullName].SetTo(this); return; } PropertyInfo[] props = t.GetProperties(BindingFlags.Instance | BindingFlags.Public); props = props.ToList().OrderBy(x => x.Name).ToArray(); foreach (var p in props) { if (p.hasAttribute(imbAttributeName.measure_excludeFromMetrics)) { IgnoreComputations.Add(p); IgnoreComputationsDict.Add(p.Name, p); continue; } if (p.GetIndexParameters().Length == 0) { if (p.PropertyType == typeof(Int32)) { Integers.Add(p); IntegersDict.Add(p.Name, p); } else if (p.PropertyType == typeof(Double)) { Doubles.Add(p); DoublesDict.Add(p.Name, p); } else if (p.PropertyType == typeof(Decimal)) { Decimals.Add(p); DecimalsDict.Add(p.Name, p); } } } MetricsExtensions.StoreMetricsDefinition(this); }
public void CheckForConfirmedPivot() { if (drawHigh && Bars.Low[0] <= lastHighPrice - threshold) { if (zagBars.Count == 0 || lastHighBar > zagBars[0]) { zigBars.Add(lastHighBar); zigHighs.Add(lastHighPrice); drawHigh = false; if (zagBars.Count > 0) { Chart.DrawLine(Drawing.Color, zagBars[0], lastLowPrice, zigBars[0], lastHighPrice, LineStyle.Solid); // DrawDownTrend(); // DrawHorizontal(lastHighPrice-100); LogNewHigh(); lastLowPrice = int.MaxValue; } } } else if (!drawHigh && Bars.High[0] >= lastLowPrice + threshold) { if (zigBars.Count == 0 || lastLowBar > zigBars[0]) { zagBars.Add(lastLowBar); zagLows.Add(lastLowPrice); drawHigh = true; if (zigBars.Count > 0) { Chart.DrawLine(Drawing.Color, zagBars[0], lastLowPrice, zigBars[0], lastHighPrice, LineStyle.Solid); // DrawUpTrend(); // DrawHorizontal(lastLowPrice+100); LogNewLow(); lastHighPrice = 0; } } } }
public override bool OnIntervalClose() { double currLow = Bars.Low[0]; if (lowest == 0) { lowest = currLow; } else { if (currLow < lowest) { lowest = currLow; } } // DO NOT DELETE : Turn to hidden instead if necessary. this[0] = lowest; pivot = 0; pivotBar = 0; for (int mainLoop = rightStrength; mainLoop < length; mainLoop++) { pivotPassed = true; leftPassed = true; pivotHigh = Bars.High[mainLoop] + 1; for (int i = mainLoop - rightStrength; i < mainLoop; i++) { if (pivotHigh < Bars.High[i]) { pivotPassed = false; break; } } if (pivotPassed) { for (int i = mainLoop + 1; i <= mainLoop + leftStrength; i++) { if (pivotHigh < Bars.High[i]) { leftPassed = false; break; } } } if (leftPassed && pivotPassed) { pivot = pivotHigh; pivotBar = mainLoop; break; } } if (leftPassed && pivotPassed && (pivotHighs.Count == 0 || pivot != pivotHighs[0])) { if (pivot > this[pivotBar]) { lowest = pivot; pivotHighs.Add(pivot); int bar = Bars.CurrentBar - pivotBar; pivotBars.Add(bar); Elapsed elapsed = default(Elapsed); if (pivotBars.Count > 1) { elapsed = Bars.Time[pivotBar] - Bars.Time[Bars.CurrentBar - pivotBars[1]]; } if (!disableBoxes) { Chart.DrawBox(Drawing.Color, bar, pivot); if (pivotBars.Count > 1) { Log.Debug("|Pivot High," + Bars.Time[pivotBar] + "," + elapsed.TotalSeconds + "," + Bars.Time[pivotBar] + "," + Bars.Time[Bars.CurrentBar - pivotBars[1]]); } } } } return(true); }
/// <summary> /// Adds or updates storage content. /// </summary> /// <param name="type">The type of the storage content.</param> /// <param name="name">The name of the storage content.</param> /// <param name="newContent">The new storage content.</param> public static void SetObject(string type, string name, object newContent) { switch (type.ToLower()) { case "pokemon": if (Pokemons.ContainsKey(name)) { Pokemons[name] = (BasePokemon)newContent; } else { Pokemons.Add(name, (BasePokemon)newContent); } break; case "string": case "str": if (Strings.ContainsKey(name)) { Strings[name] = Convert.ToString(newContent); } else { Strings.Add(name, Convert.ToString(newContent)); } break; case "integer": case "int": if (Integers.ContainsKey(name)) { Integers[name] = @int(newContent); } else { Integers.Add(name, @int(newContent)); } break; case "boolean": case "bool": if (Booleans.ContainsKey(name)) { Booleans[name] = Convert.ToBoolean(newContent); } else { Booleans.Add(name, Convert.ToBoolean(newContent)); } break; case "item": if (Items.ContainsKey(name)) { Items[name] = (BaseItem)newContent; } else { Items.Add(name, (BaseItem)newContent); } break; case "single": case "sng": if (Singles.ContainsKey(name)) { Singles[name] = sng(newContent); } else { Singles.Add(name, sng(newContent)); } break; case "double": case "dbl": if (Doubles.ContainsKey(name)) { Doubles[name] = dbl(newContent); } else { Doubles.Add(name, dbl(newContent)); } break; } }
private void BuildDfaSets() { Debug.Assert(Grammar.ParseTable != null); var terminalSets = new List <Integers>(); for (var stateNo = 0; stateNo < Grammar.ParseTable.NumberOfStates; ++stateNo) { var terminalSet = new Integers(); for (var symNo = 0; symNo < Grammar.ParseTable.NumberOfTerminals; ++symNo) { switch (Grammar.ParseTable[stateNo][symNo].Action) { case ParseAction.Accept: case ParseAction.Shift: case ParseAction.Reduce: terminalSet.Add(symNo); break; } } Debug.Assert(!terminalSet.IsEmpty); terminalSets.Add(terminalSet); } var ts = new List <(Terminal terminal, int index)>(Grammar.Terminals.Where(t => t.IsPid).Select((t, i) => (t, i))); var terminals = Grammar.Terminals.Where(t => t.IsPid).ToList(); var tDfas = Enumerable.Repeat(FA.None(), terminals.Count).ToArray(); var result = Parallel.ForEach(ts, x => { var terminal = x.terminal; var index = x.index; var fa = terminal.Raw.Expression.GetFA(); fa = fa.ToDfa(); fa = fa.Minimize(); fa = fa.RemoveDead(); foreach (var state in fa.Finals) { state.SetPayload(terminal.Id); } tDfas[index] = fa; }); Debug.Assert(result.IsCompleted); var terminalDfas = tDfas.ToList(); var already = new Dictionary <Integers, int>(); var stateDfas = new List <int>(); foreach (var terminalSet in terminalSets) { Debug.Assert(!terminalSet.IsEmpty); if (!already.TryGetValue(terminalSet, out var index)) { index = already.Count; already.Add(terminalSet, already.Count); } stateDfas.Add(index); } var dfas = Enumerable.Repeat(FA.None(), already.Count).ToArray(); result = Parallel.ForEach(already, kv => { var terminalSet = kv.Key; var index = kv.Value; FA dfa; if (terminalSet.Cardinality == 1) { dfa = terminalDfas[terminalSet.Single()].Clone().RemoveDead(); } else { dfa = Combine(terminalSet.Select(i => terminalDfas[i])); } var finals = dfa.Finals.Select(s => s.Payload).Distinct().OrderBy(p => p).ToList(); var numbers = terminalSet.Distinct().OrderBy(p => p).ToList(); Debug.Assert(finals.SequenceEqual(numbers)); dfas[index] = dfa; }); FA Combine(IEnumerable <FA> fas) { FA combined = fas.First().Clone(); foreach (var fa in fas.Skip(1)) { combined = combined.Union(fa, true); } return(combined); } Debug.Assert(result.IsCompleted); Debug.Assert(Grammar.Table != null); Debug.Assert(stateDfas.Count == Grammar.Table.GetLength(0)); Grammar.Dfas = dfas.ToArray(); Grammar.StateToDfa = stateDfas; }
public void LoadValues() { var typesBinder = new MappedTypesBinder { KnownTypes = { { "String", typeof(StringResource) }, { "Integer", typeof(IntegerResource) }, { "Dimension", typeof(DimensionResource) }, { "Colour", typeof(ColourResource) } } }; foreach (var file in ValueFiles) { var path = Path.Combine(config.Paths.Values, file); log.Verbose(Tag, "Deserialising '{0}'", path); var content = File.ReadAllText(path); var values = JsonConvert.DeserializeObject <Dictionary <string, IValueResource> >(content, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Objects, Binder = typesBinder, Converters = new JsonConverter[] { new DimensionConverter(this), new ColourConverter(this), new StringConverter(this), new IntegerConverter(this) } }); values.ForEach(p => { var key = p.Key; var resource = p.Value; if (resource is DimensionResource) { if (Dimensions.ContainsKey(key)) { throw new DuplicateValueNameException("Dimension", key); } Dimensions.Add(key, (resource as DimensionResource).Value); } else if (resource is IntegerResource) { if (Integers.ContainsKey(key)) { throw new DuplicateValueNameException("Integer", key); } Integers.Add(key, (resource as IntegerResource).Value); } else if (resource is StringResource) { if (Strings.ContainsKey(key)) { throw new DuplicateValueNameException("String", key); } Strings.Add(key, (resource as StringResource).Value); } else if (resource is ColourResource) { if (Colours.ContainsKey(key)) { throw new DuplicateValueNameException("Colour", key); } Colours.Add(key, (resource as ColourResource).Value); } }); } }
public void Add(double value) { int x = (int)value; integers.Add(x); }
public override bool OnIntervalClose() { double currHigh = Bars.High[0]; if (highest == 0) { highest = currHigh; } else { if (currHigh > highest) { highest = currHigh; } } // DO NOT DELETE. Turn to hidden instead if necessary. this[0] = highest; pivot = 0; for (int MAINLOOP = RSTREN; MAINLOOP < LENGTH; MAINLOOP++) { rightPassed = true; leftPassed = true; SHBAR = Bars.Low[MAINLOOP] - 1; for (int VALUE1 = MAINLOOP - RSTREN; VALUE1 <= MAINLOOP - 1; VALUE1++) { if (SHBAR > Bars.Low[VALUE1]) { rightPassed = false; break; } } if (rightPassed) { for (int VALUE1 = MAINLOOP + 1; VALUE1 <= MAINLOOP + LSTREN; VALUE1++) { if (SHBAR > Bars.Low[VALUE1]) { leftPassed = false; break; } } } if (rightPassed && leftPassed) { pivot = SHBAR; pivotBar = MAINLOOP; break; } } if (leftPassed && rightPassed && (pivotLows.Count == 0 || pivot != pivotLows[0])) { if (pivot < this[pivotBar]) { highest = pivot; pivotLows.Add(pivot); int bar = Bars.CurrentBar - pivotBar; pivotBars.Add(bar); Elapsed elapsed = default(Elapsed); if (pivotBars.Count > 1) { elapsed = Bars.Time[pivotBar] - Bars.Time[Bars.CurrentBar - pivotBars[1]]; } if (!disableBoxes) { Chart.DrawBox(Drawing.Color, bar, pivot); if (pivotBars.Count > 1) { Log.Debug("|Pivot Low," + Bars.Time[pivotBar] + "," + elapsed.TotalSeconds + "," + Bars.Time[pivotBar] + "," + Bars.Time[Bars.CurrentBar - pivotBars[1]]); } } } } return(true); }