Ejemplo n.º 1
0
        private TaggedProcessResult ProcessElement([NotNull] SampleRecord record,
                                                   [NotNull] IAccumulator processor)
        {
            var processResult = processor.Process(record.PulseSequence);

            return(new TaggedProcessResult(processResult, record.Id));
        }
Ejemplo n.º 2
0
    public void GetInformation(IPhone factory)
    {
        IDisplay     display     = factory.CreateDisplay();
        IAccumulator accumulator = factory.CreateAccumulator();

        Console.WriteLine($"Заряд батарии {display.GetAccumulatorVolume(accumulator)}");
    }
Ejemplo n.º 3
0
 public void Compute(Tensor values, IAccumulator accumulator = null)
 {
     if (accumulator == null)
     {
         accumulator = new IndexLookupAccumulator();
     }
 }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 6
0
        public void ClientMethod(ITelephoneFactory factory)
        {
            IDisplay     display     = factory.CreateDisplay();
            IAccumulator accumulator = factory.CreateAccumulator();

            Console.WriteLine(accumulator.ShowBatteryVolume());
            Console.WriteLine(accumulator.ShowBatteryChargeLevel(display));
        }
Ejemplo n.º 7
0
 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));
        }
Ejemplo n.º 9
0
 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);
 }
Ejemplo n.º 10
0
 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);
 }
Ejemplo n.º 11
0
        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>);
        }
Ejemplo n.º 12
0
 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();
 }
Ejemplo n.º 13
0
 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);
 }
Ejemplo n.º 14
0
 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();
 }
Ejemplo n.º 15
0
 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);
 }
Ejemplo n.º 16
0
        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");
            }
        }
Ejemplo n.º 17
0
        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);
        }
Ejemplo n.º 18
0
 /// <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;
         }
     }
 }
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 20
0
 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.");
     }
 }
Ejemplo n.º 21
0
        public IncrementalRenderer()
        {
            ViewsPerFrame = 1;

            SampleCount        = 16;
            TotalSampleCount   = MaxTotalSampleCount;
            ShuffleLensSamples = true;

            // draw all views at once
            //viewsPerFrame = maxIterations;

            //accumulator = new BufferAccumulator();
            accumulator = new FboAccumulator();
        }
Ejemplo n.º 22
0
        public IncrementalRenderer()
        {
            ViewsPerFrame = 1;

            SampleCount = 16;
            TotalSampleCount = MaxTotalSampleCount;
            ShuffleLensSamples = true;

            // draw all views at once
            //viewsPerFrame = maxIterations;

            //accumulator = new BufferAccumulator();
            accumulator = new FboAccumulator();
        }
Ejemplo n.º 23
0
            /// <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);
                }
            }
Ejemplo n.º 24
0
        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));
            }
        }
Ejemplo n.º 25
0
        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.");
                }
            });
        }
Ejemplo n.º 26
0
        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) {
                }
            }
        }
Ejemplo n.º 28
0
            /// <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);
            }
Ejemplo n.º 29
0
 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;
 }
Ejemplo n.º 30
0
        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));
            }
        }
Ejemplo n.º 31
0
        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);
        }
Ejemplo n.º 32
0
 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());
 }
Ejemplo n.º 33
0
 public void Merge(IAccumulator <double, double> other)
 {
     _min = Math.Min(_min, other.GetLocalValue());
 }
Ejemplo n.º 34
0
 public void Merge(IAccumulator <double, double> other)
 {
     _max = Math.Max(_max, other.GetLocalValue());
 }
Ejemplo n.º 35
0
        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);
        }
Ejemplo n.º 36
0
        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);

        }
Ejemplo n.º 37
0
        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;
        }
Ejemplo n.º 38
0
        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;
 }