SpikePriorityQueue.cs

Go to the documentation of this file.

namespace SpikingNeuronNetwork.Lib
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;

    public class SpikePriorityQueue : ICollection<Spike>
    {
        private readonly SortedDictionary<double, Queue<int>> _baseQueue;

        public static SpikePriorityQueue CreateSpikeQueue(IEnumerable<Spike> inputSpikes, double currentTime)
        {
            var inputSpikeTimesList = inputSpikes.ToList();
            var spikeQueue = new SpikePriorityQueue(inputSpikeTimesList);
            if (spikeQueue.Count == 0)
            {
                return spikeQueue;
            }

            // Protect against non-causality
            while (currentTime > spikeQueue.PeekTime())
            {
                spikeQueue.Dequeue();
            }

            return spikeQueue;
        }


        public SpikePriorityQueue(IEnumerable<Spike> inputSpikes)
            : this()
        {
            foreach (var inputSpike in inputSpikes)
            {
                Add(inputSpike);
            }
        }

        public SpikePriorityQueue()
        {
            _baseQueue = new SortedDictionary<double, Queue<int>>();
        }

        #region Priority queue operations

        public void Enqueue(Spike inputSpike)
        {
            if (_baseQueue.ContainsKey(inputSpike.Time))
            {
                _baseQueue[inputSpike.Time].Enqueue(inputSpike.NeuronIndex);
            }
            else
            {
                _baseQueue.Add(inputSpike.Time, new Queue<int>(new[] {inputSpike.NeuronIndex}));    
            }            
        }

        public Spike Dequeue()
        {
            if (!IsEmpty)
            {
                var result = Peek();
                Remove(result);
                return result;
            }
            throw new InvalidOperationException("Priority queue is empty");
        }

        public int DequeueValue()
        {
            return Dequeue().NeuronIndex;
        }

        public Spike Peek()
        {
            if (!IsEmpty)
            {
                var first = _baseQueue.First();
                return new Spike { Time = first.Key, NeuronIndex = first.Value.Peek()};
            }
            throw new InvalidOperationException("Priority queue is empty");
        }

        public double PeekTime()
        {
            return Peek().Time;
        }

        public bool IsEmpty
        {
            get { return _baseQueue.Count == 0; }
        }

        public bool Update(Spike oldSpike, double newFiringTime)
        {
            if (!Remove(oldSpike))
                return false;
            if (!Double.IsInfinity(newFiringTime))
            {
                Add(new Spike { Time = newFiringTime, NeuronIndex = oldSpike.NeuronIndex });
            }
            return true;
        }

        public void AddRange(ICollection<Spike> spikes)
        {
            foreach (var spike in spikes)
            {
                Add(spike);
            }
        }

        #endregion

        #region ICollection<Spike> implementation

        public void Add(Spike spike)
        {
            Enqueue(spike);
        }

        public void Clear()
        {
            _baseQueue.Clear();
        }

        public bool Contains(Spike spike)
        {
            if (!_baseQueue.ContainsKey(spike.Time))
            {
                return false;
            }
            return _baseQueue[spike.Time].Contains(spike.NeuronIndex);
        }

        public int Count
        {
            get { return _baseQueue.Sum(x => x.Value.Count); }
        }

        public void CopyTo(Spike[] array, int arrayIndex)
        {
            var arrayList = new List<Spike>();
            foreach (var kvp in _baseQueue)
            {
                var queueList = kvp.Value.ToList();
                arrayList.AddRange(queueList.Select(item => new Spike { Time = kvp.Key, NeuronIndex = item}));
            }
            arrayList.CopyTo(array, arrayIndex);
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(Spike spike)
        {
            // find element in the collection and remove it
            if (!_baseQueue.ContainsKey(spike.Time))
            {
                return false;
            }
            if (_baseQueue[spike.Time].Count == 1)
            {
                _baseQueue.Remove(spike.Time);
                return true;
            }
            // This is expensive, should be avoided
            var queueList = _baseQueue[spike.Time].ToList();
            queueList.Remove(spike.NeuronIndex);
            _baseQueue[spike.Time] = new Queue<int>(queueList);
            return true;
        }

        public IEnumerator<Spike> GetEnumerator()
        {
            return (from kvp in _baseQueue
                    from item in kvp.Value.ToList()
                    select new Spike{ Time = kvp.Key, NeuronIndex = item}).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion        
    }
}