private TaggedProcessResult ProcessElement([NotNull] SampleRecord record, [NotNull] IAccumulator processor) { var processResult = processor.Process(record.PulseSequence); return(new TaggedProcessResult(processResult, record.Id)); }
public void GetInformation(IPhone factory) { IDisplay display = factory.CreateDisplay(); IAccumulator accumulator = factory.CreateAccumulator(); Console.WriteLine($"Заряд батарии {display.GetAccumulatorVolume(accumulator)}"); }
public void Compute(Tensor values, IAccumulator accumulator = null) { if (accumulator == null) { accumulator = new IndexLookupAccumulator(); } }
public virtual IAccumulator Join(IAccumulator inner) { if (inner.HighestBoundColumnIndex < HighestBoundColumnIndex) { // Swap the join order return(inner.Join(this)); } // Inner needs to be materialized to allow rewinds if (inner is VirtualizingAccumulator) { inner = (inner as VirtualizingAccumulator).Materialize(); } bool haveOverlap = false; for (int i = 0; i < IsBound.Length && !haveOverlap; i++) { haveOverlap = IsBound[i] && inner.IsBound[i]; } if (!haveOverlap) { return(Product(inner)); } var sortedOuter = Sort(Columns.Where((x, i) => IsBound[i] && inner.IsBound[i])); var sortedInner = inner.Sort(Columns.Where((x, i) => IsBound[i] && inner.IsBound[i])); return(JoinSorted(sortedOuter, sortedInner)); }
public static bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i >= 0; i--) { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.AdditiveIdentity); } signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { signals.Insert(0, Std.DefineConstant(acc.Value)); } return(changed); }
public void ClientMethod(ITelephoneFactory factory) { IDisplay display = factory.CreateDisplay(); IAccumulator accumulator = factory.CreateAccumulator(); Console.WriteLine(accumulator.ShowBatteryVolume()); Console.WriteLine(accumulator.ShowBatteryChargeLevel(display)); }
protected AccumulatorBase(IAccumulator src, IAccumulator joined) { Columns = new List<string>(src.Columns); IsBound = src.IsBound.Select((x, i) => x || joined.IsBound[i]).ToArray(); HighestBoundColumnIndex = Math.Max(src.HighestBoundColumnIndex, joined.HighestBoundColumnIndex); BoundVariables = IsBound.Where(x => x).Select((x, i) => Columns[i]).ToList(); SortOrder = new List<int>(src.SortOrder); }
public void GetInfo(IAbstractFactory abstractFactory) { IAccumulator accumulator = abstractFactory.CreateAccumulator(); IDisplay display = abstractFactory.CreateDisplay(); Console.WriteLine(display.GetDisplayDescription()); Console.WriteLine(display.GetAccumulatorType(accumulator)); }
protected AccumulatorBase(IAccumulator src, IAccumulator joined) { Columns = new List <string>(src.Columns); IsBound = src.IsBound.Select((x, i) => x || joined.IsBound[i]).ToArray(); HighestBoundColumnIndex = Math.Max(src.HighestBoundColumnIndex, joined.HighestBoundColumnIndex); BoundVariables = IsBound.Where(x => x).Select((x, i) => Columns[i]).ToList(); SortOrder = new List <int>(src.SortOrder); }
public Observer(ICamera camera, int imageWidth, int imageHeight) { Camera = camera; Accumulator = new Accumulator(imageWidth, imageHeight); Camera.AspectRatio = (float)Accumulator.Width / Accumulator.Height; Camera.OnMoved += (_, _) => Accumulator.Clear(); Camera.Film.SampleRegistered += (_, sample) => Accumulator.Add(sample); }
public virtual void AddAccumulator <TValue, TResult>(string name, IAccumulator <TValue, TResult> accumulator) { if (_accumulators.ContainsKey(name)) { throw new InvalidOperationException($"The accumulator '{name}' already exists and cannot be added."); } _accumulators.Add(name, accumulator as IAccumulator <object, object>); }
public UPnPModeratedStateVariable(string VarName, Type VarType, bool SendEvents) : base(VarName, VarType, SendEvents) { this.Accumulator = new DefaultAccumulator(); this.PendingObject = null; this.Seconds = 0.0; this.PendingEvents = 0; this.t = new LifeTimeMonitor(); this.InitMonitor(); }
protected AccumulatorBase(IAccumulator src ) { Columns = new List<string>(src.Columns); IsBound = new bool[src.IsBound.Length]; src.IsBound.CopyTo(IsBound, 0); HighestBoundColumnIndex = src.HighestBoundColumnIndex; BoundVariables = new List<string>(src.BoundVariables); SortOrder = new List<int>(src.SortOrder); }
public UPnPModeratedStateVariable(string VarName, object VarValue, string[] AllowedValues) : base(VarName, VarValue, AllowedValues) { this.Accumulator = new DefaultAccumulator(); this.PendingObject = null; this.Seconds = 0.0; this.PendingEvents = 0; this.t = new LifeTimeMonitor(); this.InitMonitor(); }
protected AccumulatorBase(IAccumulator src) { Columns = new List <string>(src.Columns); IsBound = new bool[src.IsBound.Length]; src.IsBound.CopyTo(IsBound, 0); HighestBoundColumnIndex = src.HighestBoundColumnIndex; BoundVariables = new List <string>(src.BoundVariables); SortOrder = new List <int>(src.SortOrder); }
public RNGVenturaProvider(IAccumulator accumulator, IGenerator generator, Stream stream) { this.accumulator = accumulator ?? throw new ArgumentNullException(); this.generator = generator ?? throw new ArgumentNullException(); this.stream = stream ?? throw new ArgumentException(); if (!stream.CanRead || !stream.CanSeek || !stream.CanWrite) { throw new ArgumentException("Stream must be readable/writable/seekable"); } }
internal void Initialize(bool isCacheData, bool keepItems) { Debug.Assert(_getter.StatChannel != null); Debug.Assert(_services._statisticsCollector != null); _dataCache = isCacheData ? GetStorageForCacheData(_services._statisticsCollector, keepItems) : GetStorageForResource(_services._statisticsCollector, keepItems); _accumulator = _getter.ReturnAccumulator(_dataCache, GetResource); IsTracking = _services._settingsHolder.Settings.AutoSubscription; _getter.StatChannel.Register(Name); }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { if ((this._parent.Accumulator == null)) { IAccumulator accumulatorCasted = item.As<IAccumulator>(); if ((accumulatorCasted != null)) { this._parent.Accumulator = accumulatorCasted; return; } } }
private IAccumulator Product(IAccumulator other) { var product = new Accumulator(Columns, BoundVariables.Union(other.BoundVariables)); /* * IEnumerable<ulong[]> outerEnumerator, innerEnumerator; * if (this.HighestBoundColumnIndex < other.HighestBoundColumnIndex) * { * outerEnumerator = this.Rows; * innerEnumerator = other.Rows; * } * else * { * // This accumulator needs to be inner, so if it is a virtual one we need to materialize it first * if (this is VirtualizingAccumulator) * { * return (this as VirtualizingAccumulator).Materialize().Product(other); * } * outerEnumerator = other.Rows; * innerEnumerator = this.Rows; * } * foreach(var outer in outerEnumerator) * { * foreach(var inner in innerEnumerator) * { * product.AddRow(RowJoin(outer, inner)); * } * } */ IEnumerable <ulong[]> outerEnumerator = this.Rows; IEnumerable <ulong[]> innerEnumerator = other.Rows; foreach (var outer in outerEnumerator) { foreach (var inner in innerEnumerator) { product.AddRow(RowJoin(outer, inner)); } } // Update the sort order for the product product.SortOrder = this.SortOrder; foreach (var sortCol in other.SortOrder) { if (!product.SortOrder.Contains(sortCol)) { product.SortOrder.Add(sortCol); } } return(product); }
public void Merge(IAccumulator <double, double> other) { if (other is AverageAccumulator avg) { _count += avg._count; _sum += avg._sum; } else { throw new NotSupportedException("The merged accumulator must be AverageAccumulator."); } }
public IncrementalRenderer() { ViewsPerFrame = 1; SampleCount = 16; TotalSampleCount = MaxTotalSampleCount; ShuffleLensSamples = true; // draw all views at once //viewsPerFrame = maxIterations; //accumulator = new BufferAccumulator(); accumulator = new FboAccumulator(); }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { IAccumulator measurementsCasted = item.As <IAccumulator>(); if ((measurementsCasted != null)) { this._parent.Measurements.Add(measurementsCasted); } IAccumulatorLimit limitsCasted = item.As <IAccumulatorLimit>(); if ((limitsCasted != null)) { this._parent.Limits.Add(limitsCasted); } }
public IAccumulator Subtract(IValueStructure operand) { object other; if (ValueConverter <T> .TryConvertLosslessFrom(operand, out other)) { _value = _value.Subtract((T)other); return(this); } else { IAccumulator acc = Escalate(operand.TypeId, _value, false); return(acc.Subtract(operand)); } }
public AccumulatingBufferBlock(IAccumulator <T> accumulator, ILogger <AccumulatingBufferBlock <T> > logger) { Accumulator = accumulator; Logger = logger; AccumBlock = new ActionBlock <IEnumerable <T> >(itemsEnumerable => { var items = itemsEnumerable.ToArray(); lock (AccumulatorLock) { Logger.LogTrace($"AccumBlock adding {items.Length} items."); Accumulator.AddRange(items); Logger.LogTrace("AccumBlock adding done."); } }); }
public static bool SimplifyFactors(ISignalSet signals) { bool changed = CollectFactors(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.MultiplicativeIdentity); } signals.RemoveAt(i); changed = true; if (Std.IsConstantAdditiveIdentity(s)) { signals.Clear(); signals.Add(UndefinedSymbol.Constant); return(true); } acc = acc.Multiply(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.MultiplicativeIdentity)) { Signal first = signals[0]; if (Std.IsConstantComplex(first)) { acc = acc.Divide(first.Value).Invert(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return(changed); }
public override void Step(T container, string selector) { var value = Accessor.Read(container, selector); if (value != null) { if (_accumulator == null) { _accumulator = AccumulatorFactory.Create(value.GetType()); } try { _accumulator.Add(value); } catch (FormatException) { } catch (InvalidCastException) { } } }
/// <summary> /// Removes the given item from the collection /// </summary> /// <returns>True, if the item was removed, otherwise False</returns> /// <param name="item">The item that should be removed</param> public override bool Remove(IModelElement item) { IAccumulator accumulatorItem = item.As <IAccumulator>(); if (((accumulatorItem != null) && this._parent.Measurements.Remove(accumulatorItem))) { return(true); } IAccumulatorLimit accumulatorLimitItem = item.As <IAccumulatorLimit>(); if (((accumulatorLimitItem != null) && this._parent.Limits.Remove(accumulatorLimitItem))) { return(true); } return(false); }
public AccumulatingDataFlowCommand( IOptions <ProgramOptions> optionsAccssor, IReader <TSource> reader, Func <IProcessor <TSource, TTarget> > processor, Func <IWriter <TTarget> > writer, ILogger <AccumulatingDataFlowCommand <TSource, TTarget> > logger, ICompletionWriter <TTarget> completionWriter = null, IAccumulator <TTarget> accumulator = null ) { Options = optionsAccssor?.Value; Reader = reader; Processor = processor; Writer = writer; Logger = logger; CompletionWriter = completionWriter; Accumulator = accumulator; }
public IAccumulator Divide(IValueStructure operand) { object other; if (ValueConverter <T> .TryConvertLosslessFrom(operand, out other)) { TDivision res = _value.Divide((T)other); if (_value is IAlgebraicDivisionExtension <T, T> ) { _value = (T)(object)res; return(this); } return(Escalate <TDivision, TDivision>(res)); } else { IAccumulator acc = Escalate(operand.TypeId, _value, true); return(acc.Divide(operand)); } }
public static bool SimplifySummands(ISignalSet signals) { bool changed = CollectSummands(signals); if (signals.Count < 2) { return(changed); } IAccumulator acc = null; for (int i = signals.Count - 1; i > 0; i--) //don't touch first item! { Signal s = signals[i]; if (Std.IsConstantComplex(s)) { if (acc == null) { acc = Accumulator <IntegerValue, RationalValue> .Create(IntegerValue.AdditiveIdentity); } signals.RemoveAt(i); changed = true; acc = acc.Add(s.Value); } } if (acc != null && !acc.Value.Equals(IntegerValue.AdditiveIdentity)) { Signal first = signals[0]; if (Std.IsConstantComplex(first)) { acc = acc.Subtract(first.Value).Negate(); signals[0] = Std.DefineConstant(acc.Value); changed = true; } else { signals.Insert(1, Std.DefineConstant(acc.Value)); } } return(changed); }
private void debugList(string title, string pair, TimeFrame timeFrame, IAccumulator accum) { if (!debug) return; log.debug("roll "+title+":" + pair + ":" + ExpertFactory.timeFrameMap[timeFrame]); StringBuilder sb = new StringBuilder(); writeShortenedList(accum.getList(), sb); log.debug(title + "(" + accum.getList().Count + ")=" + sb.ToString()); }
public void Merge(IAccumulator <double, double> other) { _min = Math.Min(_min, other.GetLocalValue()); }
public void Merge(IAccumulator <double, double> other) { _max = Math.Max(_max, other.GetLocalValue()); }
private void rollDetail(string pair, int offset, TimeFrame baseTimeFrame, IAccumulator accumHi, IAccumulator accumLo, PriceComponent highComp, PriceComponent lowComp) { double high = Double.NaN; double low = Double.NaN; IAccumulator accumHi2 = getAccum(pair, baseTimeFrame, highComp); IAccumulator accumLo2 = getAccum(pair, baseTimeFrame, lowComp); List<double> ldh = accumHi2.getList(); if (ldh.Count >= offset) { List<double> ldh2 = ldh.GetRange(ldh.Count - offset, offset); high = ldh2.Max(); } List<double> ldl = accumLo2.getList(); if (ldl.Count >= offset) { List<double> ldl2 = ldh.GetRange(ldh.Count - offset, offset); low = ldl2.Min(); } if (!Double.IsNaN(high)) accumHi.addLast(high); if (!Double.IsNaN(low)) accumLo.addLast(low); }
public virtual IAccumulator Join(IAccumulator inner) { if (inner.HighestBoundColumnIndex < HighestBoundColumnIndex) { // Swap the join order return inner.Join(this); } // Inner needs to be materialized to allow rewinds if (inner is VirtualizingAccumulator) { inner = (inner as VirtualizingAccumulator).Materialize(); } bool haveOverlap = false; for(int i = 0; i < IsBound.Length && !haveOverlap; i++) { haveOverlap = IsBound[i] && inner.IsBound[i]; } if (!haveOverlap) { return Product(inner); } var sortedOuter = Sort(Columns.Where((x, i) => IsBound[i] && inner.IsBound[i])); var sortedInner = inner.Sort(Columns.Where((x, i) => IsBound[i] && inner.IsBound[i])); return JoinSorted(sortedOuter, sortedInner); }
private IAccumulator Product(IAccumulator other) { var product = new Accumulator(Columns, BoundVariables.Union(other.BoundVariables)); /* IEnumerable<ulong[]> outerEnumerator, innerEnumerator; if (this.HighestBoundColumnIndex < other.HighestBoundColumnIndex) { outerEnumerator = this.Rows; innerEnumerator = other.Rows; } else { // This accumulator needs to be inner, so if it is a virtual one we need to materialize it first if (this is VirtualizingAccumulator) { return (this as VirtualizingAccumulator).Materialize().Product(other); } outerEnumerator = other.Rows; innerEnumerator = this.Rows; } foreach(var outer in outerEnumerator) { foreach(var inner in innerEnumerator) { product.AddRow(RowJoin(outer, inner)); } } */ IEnumerable<ulong[]> outerEnumerator = this.Rows; IEnumerable<ulong[]> innerEnumerator = other.Rows; foreach(var outer in outerEnumerator) { foreach(var inner in innerEnumerator) { product.AddRow(RowJoin(outer, inner)); } } // Update the sort order for the product product.SortOrder = this.SortOrder; foreach(var sortCol in other.SortOrder) { if(!product.SortOrder.Contains(sortCol)) product.SortOrder.Add(sortCol); } return product; }
private static IAccumulator JoinSorted(IAccumulator outer, IAccumulator inner) { var output = new Accumulator(outer, inner); IEnumerator<ulong[]> outerEnumerator = outer.Rows.GetEnumerator(); if (inner is VirtualizingAccumulator) inner = (inner as VirtualizingAccumulator).Materialize(); var innerAcc = inner as Accumulator; RewindableListEnumerator<ulong[]> innerEnumerator = innerAcc.RewindableEnumerator; //IEnumerator<ulong[]> innerEnumerator = inner.Rows.GetEnumerator(); bool keepGoing = outerEnumerator.MoveNext() && innerEnumerator.MoveNext(); while (keepGoing) { while (keepGoing && RowMatch(outerEnumerator.Current, innerEnumerator.Current)) { output.AddRow(RowJoin(outerEnumerator.Current, innerEnumerator.Current)); innerEnumerator.SetMark(); bool innerKeepGoing = innerEnumerator.MoveNext(); while (innerKeepGoing && RowMatch(outerEnumerator.Current, innerEnumerator.Current)) { output.AddRow(RowJoin(outerEnumerator.Current, innerEnumerator.Current)); innerKeepGoing = innerEnumerator.MoveNext(); } innerEnumerator.RewindToMark(); keepGoing = outerEnumerator.MoveNext(); } if (keepGoing) { var cmp = RowCompare(outerEnumerator.Current, innerEnumerator.Current); while (cmp != 0 && keepGoing) { keepGoing = cmp > 0 ? innerEnumerator.MoveNext() : outerEnumerator.MoveNext(); if (keepGoing) cmp = RowCompare(outerEnumerator.Current, innerEnumerator.Current); } } if (!keepGoing) { keepGoing = outerEnumerator.MoveNext(); if (keepGoing) { innerEnumerator.Reset(); keepGoing &= innerEnumerator.MoveNext(); } } /* while (keepGoing && RowCompare(outerEnumerator.Current, innerEnumerator.Current) < 0) keepGoing = outerEnumerator.MoveNext(); while (keepGoing && RowCompare(outerEnumerator.Current, innerEnumerator.Current) > 0) keepGoing = innerEnumerator.MoveNext(); */ } return output; }
public DefaultAccelerometer(string name, IAnalogInput acceleration, IAccumulator velocity, IAccumulator position) : base(name, DeviceType.Accelerometer) { this.acceleration = acceleration; this.velocity = velocity; this.position = position; }
public DefaultGyroscope(string name, IAnalogInput angularAcceleration, IAccumulator angularVelocity, IAccumulator angularPosition) : base(name, DeviceType.Gyroscope) { this.angularAcceleration = angularAcceleration; this.angularVelocity = angularVelocity; this.angularPosition = angularPosition; }