public void CircularBufferTestMixedUnderwrite() { var buffer = new CircularBuffer <long>(5); buffer.PushFront(0); buffer.PushFront(1); buffer.PushBack(-1); Assert.AreEqual(1, buffer.Front()); Assert.AreEqual(-1, buffer.Back()); buffer.PushFront(2); Assert.AreEqual(2, buffer.Front()); Assert.AreEqual(-1, buffer.Back()); buffer.PopBack(); Assert.AreEqual(0, buffer.Back()); Assert.AreEqual(2, buffer.Front()); buffer.PushBack(-2); Assert.AreEqual(2, buffer.Front()); Assert.AreEqual(-2, buffer.Back()); Assert.AreEqual(-2, buffer[0]); Assert.AreEqual(0, buffer[1]); Assert.AreEqual(1, buffer[2]); Assert.AreEqual(2, buffer[3]); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { var test = buffer[4]; }); Assert.AreEqual(buffer.Count, 4); Assert.AreEqual(buffer.Capacity, 5); }
public void CircularBufferTestMixedOverwrite() { var buffer = new CircularBuffer <long>(3); buffer.PushFront(0); buffer.PushFront(1); buffer.PushBack(-1); Assert.AreEqual(1, buffer.Front()); Assert.AreEqual(-1, buffer.Back()); buffer.PushFront(2); Assert.AreEqual(2, buffer.Front()); Assert.AreEqual(0, buffer.Back()); buffer.PushBack(-2); Assert.AreEqual(1, buffer.Front()); buffer.PushFront(3); Assert.AreEqual(0, buffer.Back()); buffer.PushBack(-3); Assert.AreEqual(-3, buffer[0]); Assert.AreEqual(0, buffer[1]); Assert.AreEqual(1, buffer[2]); Assert.AreEqual(1, buffer.Front()); Assert.AreEqual(-3, buffer.Back()); Assert.AreEqual(buffer.Count, 3); Assert.AreEqual(buffer.Capacity, 3); }
public void CircularBufferTestFrontUnderwrite() { var buffer = new CircularBuffer <long>(5); for (int i = 0; i < 4; i++) { buffer.PushFront(i); } buffer.PopFront(); buffer.PushFront(4); Assert.AreEqual(4, buffer.Front()); Assert.AreEqual(0, buffer.Back()); buffer.PopFront(); buffer.PushFront(5); Assert.AreEqual(0, buffer[0]); Assert.AreEqual(1, buffer[1]); Assert.AreEqual(2, buffer[2]); Assert.AreEqual(5, buffer[3]); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { var test = buffer[4]; }); Assert.AreEqual(5, buffer.Front()); Assert.AreEqual(0, buffer.Back()); Assert.AreEqual(buffer.Count, 4); Assert.AreEqual(buffer.Capacity, 5); }
/// <summary> /// Gets element at given index from top of history stack, and adds all skipped elements to reverse stack /// </summary> /// <remarks>If skipElements is bigger, then amount of elements in history, returns null, clears history and pushes all to reverse stack</remarks> /// <param name="skipElements">Amount of elements to skip from history stack</param> /// <returns>>Found element or null</returns> public IHistoryAction TravelBack(int skipElements) { if (skipElements <= 0) { throw new ArgumentOutOfRangeException(nameof(skipElements), "argument cannot be smaller or equal to 0"); } if (_historyActions.Count - skipElements <= 0) { foreach (var historyAction in _historyActions) { _reverseActions.PushFront(historyAction); } var result = _historyActions.Back(); _historyActions.Clear(); return(result); } // iterate all but one elements to skip. Last element is handled exclusivly for (int i = 0; i < skipElements - 1; i++) { PopHistory(); } return(PopHistory()); }
public void CircularBuffer_BackOfBufferOverflowByOne_CorrectItem() { var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 }); buffer.PushBack(42); Assert.That(buffer.ToArray(), Is.EqualTo(new[] { 1, 2, 3, 4, 42 })); Assert.That(buffer.Back(), Is.EqualTo(42)); }
public void CircularBuffer_BackOfBufferOverflowByOne_CorrectItem() { var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 }); buffer.PushBack(42); buffer.ToArray().Should().Equal(1, 2, 3, 4, 42); buffer.Back().Should().Be(42); }
public void CircularBuffer_Back_EmptyBufferThrowsException() { var buffer = new CircularBuffer <int>(5); Assert.That(() => buffer.Back(), Throws.Exception.TypeOf <InvalidOperationException>(). With.Property("Message").Contains("empty buffer")); }
public void CircularBuffer_Back_CorrectItem( ) { var buffer = new CircularBuffer <int> (5, new [] { 0, 1, 2, 3, 4 }); buffer.Back( ) .Should( ) .Be(4); }
public void CircularBuffer_Back_EmptyBufferThrowsException( ) { var buffer = new CircularBuffer <int> (5); Action action = () => buffer.Back( ); action.Should( ) .Throw <InvalidOperationException> ( ) .WithMessage("Cannot access an empty buffer."); }
public void CircularBuffer_WithDifferentSizeAndCapacity_BackReturnsLastArrayPosition() { // test to confirm this issue does not happen anymore: // https://github.com/joaoportela/CircullarBuffer-CSharp/issues/2 var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 }); buffer.PopFront(); // (make size and capacity different) Assert.That(buffer.Back(), Is.EqualTo(4)); }
public void CircularBufferTestExceptions() { Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer <long>(0); }); Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer <long>(-5); }); var buffer = new CircularBuffer <long>(1); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Front(); }); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Back(); }); Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { var test = buffer[-1]; }); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { var test = buffer[1]; }); Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { buffer[-1] = 0; }); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer[1] = 0; }); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopBack(); }); Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopFront(); }); }
public void CircularBufferTestConstructors() { var array = new long[5]; for (int i = 0; i < 5; i++) { array[i] = i + 10; } var buffer = new CircularBuffer <long>(15, array, 5); Assert.AreEqual(10, buffer.Back()); Assert.AreEqual(14, buffer.Front()); Assert.AreEqual(5, buffer.Count); Assert.AreEqual(15, buffer.Capacity); Assert.AreEqual(false, buffer.IsEmpty); }
public void CircularBuffer_BackOfBufferOverflowByOne_CorrectItem( ) { var buffer = new CircularBuffer <int> (5, new [] { 0, 1, 2, 3, 4 }); buffer.PushBack(42); using var scope = new AssertionScope( ); buffer.ToArray( ) .Should( ) .BeEquivalentTo(new [] { 1, 2, 3, 4, 42 }); buffer.Back( ) .Should( ) .Be(42); }
private static long HashDecks(CircularBuffer <byte> player1, CircularBuffer <byte> player2) { // not convinced this is good enough but it gets the right answer so.... var hash = 0L; hash |= player1.Front() << 24; hash |= player1.Back() << 16; hash |= player1.Count; hash <<= 32; hash |= player2.Front() << 24; hash |= player2.Back() << 16; hash |= player2.Count; return(hash); }
public void CircularBufferTestBackOverwrite() { var buffer = new CircularBuffer <long>(3); for (int i = 0; i < 5; i++) { buffer.PushBack(i); } Assert.AreEqual(4, buffer[0]); Assert.AreEqual(3, buffer[1]); Assert.AreEqual(2, buffer[2]); Assert.AreEqual(2, buffer.Front()); Assert.AreEqual(4, buffer.Back()); Assert.AreEqual(buffer.Count, 3); Assert.AreEqual(buffer.Capacity, 3); }
private static void checkBuffer(CircularBuffer buffer, int capacity, int count, object startValue, object endValue) { var array = buffer.ToArray(); Assert.AreEqual(buffer.Capacity, capacity, "capacity must be " + capacity); Assert.AreEqual(buffer.Count, count, "Count must be " + count); if (count == 0) { Assert.IsTrue(buffer.Empty, "Empty must be true"); } else { Assert.IsFalse(buffer.Empty, "Empty must be false"); } if (count == capacity) { Assert.IsTrue(buffer.Full, "Full must be true"); } else { Assert.IsFalse(buffer.Full, "Full must be false"); } Assert.AreEqual(buffer.Front(), startValue, "Front must be " + startValue); Assert.AreEqual(buffer.Back(), endValue, "Back must be " + endValue); int value = startValue != null? (Int32)startValue: 0; foreach (var i in buffer) { Assert.AreEqual(i, value, "buffer element must be " + value); value++; } if (buffer.Empty) { Assert.IsNull(array, "ToArray must be null"); } else { Assert.AreEqual(array.Length, count, "array length must be " + count); for (int i = 0; i < array.Length; i++) { Assert.AreEqual(array[i], buffer[i], "array item must be equal as buffer item, index: " + i); } } }
public void CircularBufferTestFrontAndBack() { var rand = new Random(); var buffer = new CircularBuffer <long>(3); for (int i = 0; i < 25; i++) { var cur = rand.Next(); buffer.PushFront(cur); Assert.AreEqual(cur, buffer.Front()); buffer.PopFront(); } for (int i = 0; i < 25; i++) { var cur = rand.Next(); buffer.PushBack(cur); Assert.AreEqual(cur, buffer.Back()); buffer.PopBack(); } }
public virtual Vector3 GetPosition(double timestamp) { if (dataInQueue) { lock (dataQueue){ for (int i = 0; i < dataQueue.Size; i++) { TrackingData data = dataQueue.Back(); if (data.GetType() == typeof(TrackingDataIMU)) { AddAccelerationMeasurement((TrackingDataIMU)data); } else if (data.GetType() == typeof(TrackingDataPosition)) { AddPositionMeasurement((TrackingDataPosition)data); } dataQueue.PopBack(); } dataInQueue = false; } } int lastPositionIndex = GetLastPositionIndex(); if (lastPositionIndex == -1) { // Debug.LogWarning("Couldn't find any last position"); return(lastCalculatedPosition); } float delaySinceLastGetPosition = (float)(timestamp - lastCalculatedPositionTimestamp); float delaySinceLastPositionMeasurement = lastPositionIndex == -1 ? maxSpeedViabilityDelay : (float)(timestamp - trackingDataBuffer[lastPositionIndex].timestamp); float delaySinceLastMeasurement = (float)(timestamp - (trackingDataBuffer.Size > 0 ? trackingDataBuffer[0].timestamp : 0.0d)); if (delaySinceLastMeasurement > maxPredictionDelaySinceLastMeasurement || trackingDataBuffer.Size < 1) { return(lastCalculatedPosition); } int lastAccelerationIndex = GetLastAccelerationIndex(); Vector3 lastAcceleration = lastAccelerationIndex == -1 ? Vector3.zero : ((TrackingDataIMU)trackingDataBuffer[lastAccelerationIndex]).acceleration; float delaySinceLastAccelerationMeasurement = lastAccelerationIndex == -1 ? maxAccelerationViabilityDelay : (float)(timestamp - trackingDataBuffer[lastAccelerationIndex].timestamp); List <PositionOffset> deleteList = new List <PositionOffset>(); Vector3 currentOffset = Vector3.zero; foreach (PositionOffset off in offsets) { currentOffset += off.GetOffset(timestamp); if (off.CorrectionOver(timestamp)) { deleteList.Add(off); } } foreach (PositionOffset off in deleteList) { offsets.Remove(off); } if (currentOffset.magnitude > lerpDiscardDistance || (trackingDataBuffer[lastPositionIndex].position - lastCalculatedPosition).magnitude > lerpDiscardDistance) { // if (blink) // { offsets.Clear(); if (Blink != null) { Blink(); } // } } // ACC if (trackingDataBuffer[0].GetType() == typeof(TrackingDataIMU)) { // Position calculation with Slerp in case we have been predicting with ACC for too long Vector3 newOffset = Vector3.Slerp(trackingDataBuffer[0].speed, Vector3.zero, delaySinceLastPositionMeasurement / maxSpeedViabilityDelay) * delaySinceLastGetPosition + 0.5f * Vector3.Slerp(lastAcceleration, Vector3.zero, delaySinceLastAccelerationMeasurement / maxAccelerationViabilityDelay) * delaySinceLastGetPosition * delaySinceLastGetPosition; lastCalculatedPosition = Vector3.Slerp(lastCalculatedPosition + newOffset, lastCalculatedPosition, delaySinceLastPositionMeasurement / accelerationOnlyTrackingDelay); lastCalculatedPositionTimestamp = timestamp; } // POS else { // Position calculation with Slerp in case we have been predicting with ACC for too long Vector3 newOffset = Vector3.Slerp(trackingDataBuffer[0].speed, Vector3.zero, delaySinceLastPositionMeasurement / maxSpeedViabilityDelay) * delaySinceLastGetPosition + 0.5f * Vector3.Slerp(lastAcceleration, Vector3.zero, delaySinceLastAccelerationMeasurement / maxAccelerationViabilityDelay) * delaySinceLastGetPosition * delaySinceLastGetPosition; lastCalculatedPosition = Vector3.Slerp(lastCalculatedPosition + newOffset, lastCalculatedPosition, delaySinceLastPositionMeasurement / accelerationOnlyTrackingDelay); lastCalculatedPositionTimestamp = timestamp; } /* TRY TO FIX LONG OFFSET JUMPS, if line 110 isn't enought * if ((trackingDataBuffer[lastPositionIndex].position - lastCalculatedPosition).magnitude > discardDistance) * { * ResetFilter(); * if (blink) * { * if (Blink != null) * Blink(); * } * }*/ // return lastCalculatedPosition + currentOffset; return(oneEuro.Filter(lastCalculatedPosition + currentOffset, (float)timestamp)); }
public void CircularBuffer_Back_EmptyBufferThrowsException() { var buffer = new CircularBuffer <int>(5); Assert.Throws <InvalidOperationException>(() => buffer.Back()); }
public void CircularBuffer_Back_CorrectItem() { var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 }); Assert.That(buffer.Back(), Is.EqualTo(4)); }
// Update is called at 50 FPS void FixedUpdate() { if (!m_levelBuffer.IsEmpty) { m_lastLevel = m_levelBuffer.Back(); } m_levelBuffer.PushBack(m_level.normalizedLevel); m_BPMBuffer.PushBack(BPM); var arr = m_levelBuffer.ToArray(); Array.Copy(arr, m_currentLevels, arr.Length); Array.Copy(arr, m_fftreals, arr.Length); Array.Copy(arr, m_fftcomplex, arr.Length); for (int s = 0; s < MAX_SHIFT; s++) { float sad = 0; float numSamples = 0; for (int i = 0; i < arr.Length; i++) { if (i + s < arr.Length) { sad += Mathf.Abs(arr[i] - arr[i + s]); numSamples++; } } if (numSamples > 0) { m_currentWeights[s] = sad / numSamples; } } float alpha = m_correlationLerp; for (int i = 0; i < m_weights.Length; i++) { m_weights[i] = alpha * m_weights[i] + (1.0f - alpha) * m_currentWeights[i]; } for (int i = 0; i < currentPeaks.Length; i++) { currentPeaks[i] = 0; currentPeakWeights[i] = 0; } GetPeaks(m_weights, 15); GetHarmonicFromPeaks(ref currentPeaks, ref harmonicPeaks); GetMaxBPM(); float thisFreq = BPM / 60f; if (Input.GetKeyDown(KeyCode.Space)) { phaseOffset = Time.time; } frameNum++; }