Exemplo n.º 1
0
 public PowerLogObserver(ILogger <PowerLogObserver> logger, IOptions <Settings> options, IMinerLogListener logListener)
 {
     _logger     = logger ?? throw new ArgumentNullException(nameof(logger));
     logListener = logListener ?? throw new ArgumentNullException(nameof(logListener));
     logListener.LogMessageReceived += ReceiveLogMessage;
     _settings         = options.Value;
     _movingStatistics = new MovingStatistics(_settings.StatHistorySize);
 }
Exemplo n.º 2
0
        public void StartSession(float ppi, int sensitivity)
        {
            PPI = ppi;

            var sampleWindow = sensitivity * 60; // 60 to 1200ms, at 60 frames/sec, = 1 sec to 20 seconds

            blink     = new MovingStatistics(sampleWindow);
            squint    = new MovingStatistics(sampleWindow);
            gazeIn    = new MovingStatistics(sampleWindow);
            gazeOut   = new MovingStatistics(sampleWindow);
            smile     = new MovingStatistics(sampleWindow);
            frown     = new MovingStatistics(sampleWindow);
            headSpeed = new MovingStatistics(sampleWindow);
            eyeDwell  = new MovingStatistics(sampleWindow);
            headTilt  = new MovingStatistics(sampleWindow);
        }
        public void NegativeInfinityTest()
        {
            var ms = new MovingStatistics(3);

            ms.Push(1.0);
            ms.Push(2.0);
            Assert.That(ms.Minimum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.Not.EqualTo(double.NegativeInfinity));

            ms.Push(double.NegativeInfinity);
            Assert.That(ms.Minimum, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(1.0);
            Assert.That(ms.Minimum, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(double.NegativeInfinity);
            Assert.That(ms.Minimum, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(2.0);
            Assert.That(ms.Minimum, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(3.0);
            Assert.That(ms.Minimum, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(4.0);
            Assert.That(ms.Minimum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Maximum, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.Mean, Is.Not.EqualTo(double.NegativeInfinity));
            Assert.That(ms.StandardDeviation, Is.Not.NaN);
        }
        public void NaNTest()
        {
            var ms = new MovingStatistics(3);

            Assert.That(ms.Minimum, Is.NaN);
            Assert.That(ms.Maximum, Is.NaN);
            Assert.That(ms.Mean, Is.NaN);
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(1.0);
            Assert.That(ms.Minimum, Is.Not.NaN);
            Assert.That(ms.Maximum, Is.Not.NaN);
            Assert.That(ms.Mean, Is.Not.NaN);
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(2.0);
            Assert.That(ms.Minimum, Is.Not.NaN);
            Assert.That(ms.Maximum, Is.Not.NaN);
            Assert.That(ms.Mean, Is.Not.NaN);
            Assert.That(ms.StandardDeviation, Is.Not.NaN);

            ms.Push(double.NaN);
            Assert.That(ms.Minimum, Is.NaN);
            Assert.That(ms.Maximum, Is.NaN);
            Assert.That(ms.Mean, Is.NaN);
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(1.0);
            Assert.That(ms.Minimum, Is.NaN);
            Assert.That(ms.Maximum, Is.NaN);
            Assert.That(ms.Mean, Is.NaN);
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(2.0);
            Assert.That(ms.Minimum, Is.NaN);
            Assert.That(ms.Maximum, Is.NaN);
            Assert.That(ms.Mean, Is.NaN);
            Assert.That(ms.StandardDeviation, Is.NaN);

            ms.Push(3.0);
            Assert.That(ms.Minimum, Is.Not.NaN);
            Assert.That(ms.Maximum, Is.Not.NaN);
            Assert.That(ms.Mean, Is.Not.NaN);
            Assert.That(ms.StandardDeviation, Is.Not.NaN);
        }
        public void StabilityTest()
        {
            var data = new double[1000000];

            Normal.Samples(new SystemRandomSource(0), data, 50, 10);

            var ms = new MovingStatistics(5, data);

            ms.PushRange(new[] { 11.11, 22.22, 33.33, 44.44, 55.55 });

            Assert.AreEqual(5, ms.Count);
            Assert.AreEqual(11.11, ms.Minimum);
            Assert.AreEqual(55.55, ms.Maximum);

            Assert.AreEqual(33.33, ms.Mean, 1e-11);
            Assert.AreEqual(308.58025, ms.Variance, 1e-10);
            Assert.AreEqual(17.5664524022354, ms.StandardDeviation, 1e-11);
            Assert.AreEqual(246.8642, ms.PopulationVariance, 1e-10);
            Assert.AreEqual(15.7119126779651, ms.PopulationStandardDeviation, 1e-10);
        }