public LinearRegressionInputData GetValues(
     CircularBuffer<MarketDataPair> data,
     int fromIndex)
 {
     List<MarketDataPair> rangeData = data.PeekRange(fromIndex);
     return GetLinearRegressionData(rangeData);
 }

 public WidcommBluetoothStream(CircularBuffer buffer, CircularBuffer sbuffer, byte[] address, string pin)
     : base(buffer, sbuffer, address, pin)
 {
     wdStack[0] = WidcommAPI.CreateWidcommStack();
        if (wdStack[0] == IntPtr.Zero)
        throw new Exception("Cannot create stack");
 }

        public void TestPushPop()
        {
            CircularBuffer<double> queue = new CircularBuffer<double>(3);

            queue.PushBack(1.0);
            queue.PushBack(2.0);
            queue.PushBack(3.0);

            Assert.That(queue[0], Is.EqualTo(1.0).Within(0.00005));
            Assert.That(queue[1], Is.EqualTo(2.0).Within(0.00005));
            Assert.That(queue[2], Is.EqualTo(3.0).Within(0.00005));

            //The buffer is now full.

            queue.PushBack(4.0);

            Assert.That(queue[0], Is.EqualTo(2.0).Within(0.00005));
            Assert.That(queue[1], Is.EqualTo(3.0).Within(0.00005));
            Assert.That(queue[2], Is.EqualTo(4.0).Within(0.00005));

            queue.PushBack(5.0);

            Assert.That(queue[0], Is.EqualTo(3.0).Within(0.00005));
            Assert.That(queue[1], Is.EqualTo(4.0).Within(0.00005));
            Assert.That(queue[2], Is.EqualTo(5.0).Within(0.00005));

            queue.PopBack();
            Assert.That(queue[0], Is.EqualTo(3.0).Within(0.00005));
            Assert.That(queue[1], Is.EqualTo(4.0).Within(0.00005));

            queue.PopFront();

            Assert.That(queue[0], Is.EqualTo(4.0).Within(0.00005));

        }

        public void OverflowException()
        {
            var buffer = new CircularBuffer<int>(4);

            for (int i = 0; i < 32; i++)
                buffer.Put(i);
        }

        public QueueClient Get(Address address)
        {
            var key = address.ToString();
            var buffer = queueClients.GetOrAdd(key, s =>
            {
                var b = new CircularBuffer<QueueClientEntry>(numberOfQueueClientsPerAddress);
                for (var i = 0; i < numberOfQueueClientsPerAddress; i++)
                {
                    var factory = messagingFactories.Get(address);
                    b.Put(new QueueClientEntry
                    {
                        Client = queueClientCreator.Create(address.Queue, factory)
                    });
                }
                return b;
            });

            var entry = buffer.Get();

            if (entry.Client.IsClosed)
            {
                lock (entry.mutex)
                {
                    if (entry.Client.IsClosed)
                    {
                        var factory = messagingFactories.Get(address);
                        entry.Client = queueClientCreator.Create(address.Queue, factory);
                    }
                }
            }

            return entry.Client;

        }

        public void CircularBufferExt_DecoderConvert1_BoundariesFlush()
        {
            Encoding enc = Encoding.GetEncoding("UTF-8");
            Decoder d = enc.GetDecoder();

            byte[] m = new byte[] {
                0xAC, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
                0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
                0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
                0x57, 0x58, 0x59, 0x5A, 0xE2, 0x82
            };
            char[] c = new char[28];
            CircularBuffer<byte> cb = new CircularBuffer<byte>(m, 16, m.Length);

            int bu;
            int cu;
            bool complete;

            // Based on the test "Decoder_Boundaries2"
            d.Convert(cb, c, 0, c.Length, true, out bu, out cu, out complete);
            Assert.IsTrue(complete);
            Assert.AreEqual(m.Length, bu);
            Assert.AreEqual(0, cb.Length);
            Assert.AreEqual(c.Length, cu);
            Assert.AreEqual("OPQRSTUVWXYZ€@ABCDEFGHIJKLMN", new string(c));
        }

 protected virtual void Awake()
 {
     _activeTrail = new CircularBuffer<PCTrailPoint>(MaxNumberOfPoints);
     _fadingTrails = new List<CircularBuffer<PCTrailPoint>>();
     _t = transform;
     _emit = Emit;
 }

	public void LevelReset(float liveCount){
		timeOfDeath = float.PositiveInfinity;
		playerEvents = new CircularBuffer<PlayerEvent>(2);
		roundScore = 0f;
		lived = false;
		lives = liveCount;
	}

 internal void Recycle(CircularBuffer<byte[]> buffer)
 {
     if (buffer != null)
     {
         while (buffer.Count != 0) Recycle(buffer.Pop());
     }
 }

    // Use this for initialization
    void init()
    {
        //Loop through the object prefabs and make a new list for each one.
        //We do this because the pool can only support prefabs set to it in the editor,
        //so we can assume the lists of pooled objects are in the same order as object prefabs in the array
        _objects = new CircularBuffer<GameObject>[_prefabs.Length];

        int i = 0;
        foreach ( GameObject objectPrefab in _prefabs )
        {
            _objects[i] = new CircularBuffer<GameObject>(_bufferAmount[i]);

            for ( int n=0; n<_bufferAmount[i]; n++)
            {

                GameObject obj = Instantiate(objectPrefab) as GameObject;
                obj.name = objectPrefab.name;

                obj.SetActiveRecursively(false);
                obj.transform.parent = transform;
                _objects[i].Add(obj);
            }
            i++;
        }
    }

 /// <summary>
 /// Creates a linear FIR or IIR filter.
 /// </summary>
 /// <param name="source">The <see cref="IPIDSource"/> object that is used to get values.</param>
 /// <param name="ffGains">The "feed forward" or FIR gains.</param>
 /// <param name="fbGains">The "feed back" or IIR gains.</param>
 public LinearDigitalFilter(IPIDSource source, double[] ffGains, double[] fbGains) : base(source)
 {
     m_inputs = new CircularBuffer<double>(ffGains.Length);
     m_outputs = new CircularBuffer<double>(fbGains.Length);
     m_inputGains = ffGains;
     m_outputGains = fbGains;
 }

        public MessagingFactory Get(Address address)
        {
            var key = address.ToString();
            var buffer = MessagingFactories.GetOrAdd(key, s => {
                var b = new CircularBuffer<FactoryEntry>(numberOfFactoriesPerAddress);
                for(var i = 0; i < numberOfFactoriesPerAddress; i++) 
                    b.Put(new FactoryEntry { Factory = createMessagingFactories.Create(address) });
                return b;
            });

            var entry = buffer.Get();

            if (entry.Factory.IsClosed)
            {
                lock (entry.mutex)
                {
                    if (entry.Factory.IsClosed)
                    {
                        entry.Factory = createMessagingFactories.Create(address);
                    }
                }
            }

            return entry.Factory;

        }

	public object Clone()
	{
		CircularBuffer cb = new CircularBuffer(this.Count);
		cb.buf = (double[])this.buf.Clone();
		cb.top = this.top;
		return cb;
	}

	/// <summary>
	/// 係数を配列で指定して初期化
	/// </summary>
	/// <param name="a">分母係数を格納した配列</param>
	/// <param name="b">分子係数を格納した配列</param>
	/// <param name="c">ゲイン</param>
	public IirFilter(double[] a, double[] b, double c)
	{
		this.a = a;
		this.b = b;
		this.c = c;
		this.buf = new CircularBuffer(a.Length);
	}

 public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints)
 {
     float num = Vector3.Distance(from, to);
     Vector3 normalized = (to - from).normalized;
     float num2 = 0f;
     CircularBuffer<PCTrailPoint> circularBuffer = new CircularBuffer<PCTrailPoint>(this.GetMaxNumberOfPoints());
     int num3 = 0;
     while (num2 < num)
     {
         PCTrailPoint pCTrailPoint = new PCTrailPoint();
         pCTrailPoint.PointNumber = num3;
         pCTrailPoint.Position = from + normalized * num2;
         circularBuffer.Add(pCTrailPoint);
         this.InitialiseNewPoint(pCTrailPoint);
         num3++;
         if (distanceBetweenPoints <= 0f)
         {
             break;
         }
         num2 += distanceBetweenPoints;
     }
     PCTrailPoint pCTrailPoint2 = new PCTrailPoint();
     pCTrailPoint2.PointNumber = num3;
     pCTrailPoint2.Position = to;
     circularBuffer.Add(pCTrailPoint2);
     this.InitialiseNewPoint(pCTrailPoint2);
     PCTrail pCTrail = new PCTrail(this.GetMaxNumberOfPoints());
     pCTrail.Points = circularBuffer;
     this._fadingTrails.Add(pCTrail);
 }

        public QueueProcessor(Logger log, IDataStore dataStore, IHubContext<IMatchmakingClient> hub, ITracker tracker, IMatchEvaluator matchBuilder, CircularBuffer<TimeSpan> timeToMatch)
        {
            _log = log;
            _dataStore = dataStore;
            _hub = hub;
            _tracker = tracker;
            _matchBuilder = matchBuilder;
            _timeToMatch = timeToMatch;

            _queueSleepMin = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMin") );
            _queueSleepMax = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMax") );
            _queueSleepLength = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepLength") );

            Task.Run( async () =>
            {
                _log.Info("Running QueueProcessor...");

                while( true )
                {
                    var sleepTime = _queueSleepMax;

                    try
                    {
                        await processQueue();
                        sleepTime = _queueSleepMax - (_dataStore.DocumentDbPopulation * (_queueSleepMax/_queueSleepLength));
                    }
                    catch(Exception ex)
                    {
                        _log.Error(ex);
                    }

                    Thread.Sleep(sleepTime < _queueSleepMin ? _queueSleepMin : sleepTime);
                }
            });
        }

        public byte[] Serialize(CircularBuffer<Packet> buffer)
        {
            if (buffer.Size == 0)
                return null;

            var json = JsonConvert.SerializeObject(buffer.Get());
            return Encoding.UTF8.GetBytes(json);
        }

 public Guest(string channel, IApplicationShutdown shutdown, IServiceProvider serviceProvider)
 {
     this.channel = channel;
     this.shutdown = shutdown;
     this.serviceProvider = serviceProvider;
     this.guestBuffer = new CircularBuffer(channel);
     this.hostBuffer = new CircularBuffer(channel + "*");
 }

		public void ShouldSaveWithoutOverflow()
		{
			var buffer = new CircularBuffer<int>(5);
			buffer.Add(1);
			buffer.Add(2);
			buffer.Add(3);
			CollectionAssert.AreEqual(new [] { 1, 2, 3 }, buffer);
		}

	/*
	 * coroutine
	IEnumerator YieldSign() {
		print ("spawn yield symbol");
		yield return new WaitForSeconds(2);
		PowerSpawn();
	}

	void  PowerSpawn(){
		print ("spawn power");
	}

	void Start() {
		StartCoroutine(YieldSign());
		print ("disable button");
	}
*/

	void Start(){
		CircularBuffer<int> buffer = new CircularBuffer<int>(2);
		buffer.Add(1);
		buffer.Add(2);
		buffer.Add(3);
		foreach(int i in buffer.Reverse<int>()){
			print (i);
		}
	}