public void RandomEnqueueDequeue() { var circularQueue = new CircularQueue<int>(66); var currentItems = new List<int>(); var rand = new Random(Convert.ToInt32(DateTime.Now.Ticks % Int32.MaxValue)); for (var i = 0; i < 513; i++) { var number = rand.Next(10000); if (number % 2 == 0) { circularQueue.Enqueue(number); currentItems.Add(number); } else { if (circularQueue.Count > 0) { Assert.IsTrue(currentItems.Remove(circularQueue.Dequeue())); } } foreach (var item in currentItems) { Assert.IsTrue(circularQueue.Contains(item)); } } }
public void Empty() { var circularQueue = new CircularQueue<int>(20); Assert.IsFalse(circularQueue.Contains(1)); Assert.IsFalse(circularQueue.Contains(2)); }
public void CircularQueue_EnqueueDequeueManyChunks_ShouldWorkCorrectly() { // Arrange var queue = new CircularQueue<int>(); int chunks = 100; // Act & Assert in a loop int value = 1; for (int i = 0; i < chunks; i++) { Assert.AreEqual(0, queue.Count); var chunkSize = i + 1; for (int counter = 0; counter < chunkSize; counter++) { Assert.AreEqual(value - 1, queue.Count); queue.Enqueue(value); Assert.AreEqual(value, queue.Count); value++; } for (int counter = 0; counter < chunkSize; counter++) { value--; Assert.AreEqual(value, queue.Count); queue.Dequeue(); Assert.AreEqual(value - 1, queue.Count); } Assert.AreEqual(0, queue.Count); } }
public CacheStream2(int bufferBlockSize, int bufferBlockCount, string filename) { m_bufferBlockSize = bufferBlockSize; m_bufferBlockCount = bufferBlockCount; m_file = new NativeFileReader(filename); m_queue = new CircularQueue<byte[]>(bufferBlockCount); }
public void TryEnqueue_fails_when_at_capacity() { var q = new CircularQueue<int>(1); Assume.That(() => q.TryEnqueue(0)); Check.That(() => !q.TryEnqueue(1)); }
public void OverFlow() { var circularQueue = new CircularQueue<int>(5); for (var i = 0; i < 10; i++) { circularQueue.Enqueue(i); } Assert.AreEqual(circularQueue.Count, 5); for (var i = 0; i < 5; i++) { Assert.AreEqual(circularQueue.Count, 5 - i); Assert.AreEqual(circularQueue.Dequeue(), i + 5); Assert.AreEqual(circularQueue.Count, 4 - i); } circularQueue = new CircularQueue<int>(100); for (var i = 0; i < 200; i++) { circularQueue.Enqueue(i); } for (var i = 100; i < 200; i++) { Assert.AreEqual(circularQueue.Dequeue(), i); } }
public FoxPriceData(int maxQueueCount, int oneSecCount, String code) { this._oneSecCount = oneSecCount; this._maxQueueCount = maxQueueCount; this._cq = new CircularQueue(maxQueueCount); this._code = code; }
static TetrisController() { /* 0100 0000 0100 1111 0100 0000 0100 0000 */ TetrisIGroup = new CircularQueue<ushort>(new ushort[] { 17476, 3840 }); /* 0010 0100 0011 0000 0010 0111 0010 0111 0110 0000 0010 0001 0000 0000 0000 0000 */ TetrisJGroup = new CircularQueue<ushort>(new ushort[] { 8800, 18176, 12832, 1808 }); /* 0100 0000 1100 0010 0100 1110 0100 1110 0110 1000 0100 0000 0000 0000 0000 0000 */ TetrisLGroup = new CircularQueue<ushort>(new ushort[] { 17504, 3712, 50240, 11776 }); /* 0000 0110 0110 0000 */ TetrisOGroup = new CircularQueue<ushort>(new ushort[] { 1632 }); /* 0100 0011 0110 0110 0010 0000 0000 0000 */ TetrisSGroup = new CircularQueue<ushort>(new ushort[] { 17952, 13824 }); /* 0010 0010 0000 0010 0111 0011 0111 0110 0000 0010 0010 0010 0000 0000 0000 0000 */ TetrisTGroup = new CircularQueue<ushort>(new ushort[] { 9984, 8992, 1824, 9760 }); /* 0010 0110 0110 0011 0100 0000 0000 0000 */ TetrisZGroup = new CircularQueue<ushort>(new ushort[] { 9792, 25344 }); TetrisI = new Tetris(TetrisIGroup, Brushes.Red); TetrisJ = new Tetris(TetrisJGroup, Brushes.Cyan); TetrisL = new Tetris(TetrisLGroup, Brushes.Yellow); TetrisO = new Tetris(TetrisOGroup, Brushes.Blue); TetrisS = new Tetris(TetrisSGroup, Brushes.Green); TetrisT = new Tetris(TetrisTGroup, Brushes.Orange); TetrisZ = new Tetris(TetrisZGroup, Brushes.Purple); Tetris = new List<Tetris>(new Tetris[] { TetrisI, TetrisJ, TetrisL, TetrisO, TetrisS, TetrisT, TetrisZ }); }
public void Interface() { ICollection<int> c = new CircularQueue<int>(20); Assert.IsFalse(c.Remove(5)); c.Add(2); Assert.AreEqual(c.Count, 1); Assert.IsTrue(c.Remove(2)); Assert.AreEqual(c.Count, 0); c.Add(4); c.Add(5); c.Add(6); Assert.AreEqual(c.Count, 3); Assert.IsFalse(c.Remove(2)); Assert.AreEqual(c.Count, 3); Assert.IsTrue(c.Remove(5)); Assert.AreEqual(c.Count, 2); Assert.IsTrue(c.Remove(6)); Assert.AreEqual(c.Count, 1); Assert.IsTrue(c.Remove(4)); Assert.AreEqual(c.Count, 0); }
public void EnqueueFullTest() { _circularQueue = new CircularQueue<int>(_nodes.Length); var i = 0; var next = _circularQueue.NextIndex(null); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); next = _circularQueue.NextIndex(i - 1); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); next = _circularQueue.NextIndex(i - 1); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); next = _circularQueue.NextIndex(i - 1); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); next = _circularQueue.NextIndex(i - 1); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); next = _circularQueue.NextIndex(i - 1); _circularQueue.Enqueue(i++); if (next != null) Assert.AreEqual(i - 1, _circularQueue.QueueList[next.Value], "Could not get the right value at the element - " + (i - 1)); }
public void Simple() { var circularQueue = new CircularQueue<int>(4); Assert.AreEqual(circularQueue.Count, 0); Assert.IsTrue(circularQueue.IsEmpty); Assert.IsFalse(circularQueue.IsFull); }
public void EnqueueSingleTest() { _circularQueue = new CircularQueue<int>(_nodes.Length); LoadInput(); const int expectedValue = 5; _circularQueue.Enqueue(expectedValue); Assert.AreEqual(expectedValue, _circularQueue.Dequeue(), "Could not extract the right element inserted in a full queue"); }
/// <summary> /// Create a new message connection between screen and server. /// </summary> /// <param name="receiveQueue"> Temporary queue used to store received messages. </param> /// <param name="socket"> Socket to use to send and receive messages. </param> public ScreenConnection(CircularQueue<Message> receiveQueue, Socket socket) { m_socket = socket; m_receiveQueue = receiveQueue; m_receiveBuffer = new CircularBuffer(4096); m_serializer = new TextMessageSerializer(); //m_serializer = new BinaryMessageSerializer(); }
public void Simple() { var circularQueue = new CircularQueue<int>(40); Assert.IsFalse(circularQueue.IsReadOnly); circularQueue = CircularQueueTest.GetFullTestQueue(); Assert.IsFalse(circularQueue.IsReadOnly); }
public static void Initialize(CircularQueue<Location> waypoints, int timeBetweenPulses = 333) { TimeBetweenPulses = timeBetweenPulses; // Defaults to 333 = 3 pulses every second Waypoints = waypoints; States = new List<State>(); // Instantiate a new list of states LoadInternalStates(); // Load the States from the internal assembly (subclasses of State) States.Sort(); // Sort the list by priority }
public void Empty() { var circularQueue = new CircularQueue<int>(40); var visitor = new TrackingVisitor<int>(); circularQueue.AcceptVisitor(visitor); Assert.AreEqual(visitor.TrackingList.Count, 0); }
public void Dequeue_EmptyQueue_ThrowsException() { // Arrange var queue = new CircularQueue<int>(); // Act queue.Dequeue(); // Assert: expect and exception }
public void shouldCopyUsingToArray() { var testee = new CircularQueue<int>(new[] { 1, 2, 3, 4 }); testee.Cycle(); testee.Cycle(); var expected = new[] { 3, 4, 1, 2 }; var actual = testee.ToArray(); Assert.IsTrue(actual.SequenceEqual(expected), actual.PrintContentsToString(", ")); }
public NetworkManager(IPAddress serverAddress, int serverPort) { this.serverAddress = serverAddress; this.serverPort = serverPort; this.messageQueue = new CircularQueue<Message>(256); m_conn = new ScreenConnection(this.messageQueue); m_conn.Connected += OnConnected; m_conn.ConnectFailed += OnConnectFailed; m_conn.Disconnected += OnDisconnected; }
public Screen(string name, int id, Socket socket, Server server) { m_name = name; m_id = id; m_server = server; m_bubbles = new Dictionary<int, ServerBalloon>(); m_queue = new CircularQueue<Message>(64); m_connection = new ScreenConnection(m_queue, socket); m_thread = new Thread(Run); m_thread.Start(); }
public void TryEnqueue_fails_if_write_catches_up_to_read() { var q = new CircularQueue<int>(2); int ignored; Assume.That(() => q.TryEnqueue(0)); Assume.That(() => q.TryDeque(out ignored)); Assume.That(() => q.TryEnqueue(0)); Assume.That(() => q.TryEnqueue(1)); Check.That(() => !q.TryEnqueue(2)); }
public FeedReader(Server server, string feedUrl, double pullIntervals) { this.m_server = server; this.m_feedUrl = feedUrl; this.m_interval = pullIntervals; this.m_queue = new CircularQueue<Message>(64); this.m_client = new WebClient(); this.m_timer = new System.Timers.Timer(m_interval); this.m_timer.Elapsed += (sender, args) => Refresh(); this.m_thread = new Thread(Run); this.m_thread.Start(); }
public void CircularQueue_push_cmp() { CircularQueue<int> x = new CircularQueue<int>(3); x.push(10); Assert.IsTrue(x.cmp(new[] { 10 })); x.push(15); Assert.IsTrue(x.cmp(new[] { 10, 15})); x.push(20); Assert.IsTrue(x.cmp(new[] { 10, 15, 20 })); x.push(25); Assert.IsTrue(x.cmp(new[] { 15, 20, 25 })); }
public CircularQueueTests() { var methods = new Func<int, int, int>[] { (x, y) => x + y, (x, y) => x - y, (x, y) => x * y, (x, y) => x / y }; this.testee = new CircularQueue<Func<int, int, int>>(methods); }
public void ExeptionInvalidArray1() { var circularQueue = new CircularQueue<int>(30); for (var i = 1; i < 20; i++) { circularQueue.Enqueue(i); } var array = new int[19]; circularQueue.CopyTo(array, 1); }
public void is_first_in_first_out() { var q = new CircularQueue<int>(2); Assume.That(() => q.TryEnqueue(0)); Assume.That(() => q.TryEnqueue(1)); int value; Check.That( () => q.TryDeque(out value) && value == 0, () => q.TryDeque(out value) && value == 1 ); }
public void Simple() { var circularQueue = new CircularQueue<int>(4); circularQueue.Enqueue(1); Assert.AreEqual(circularQueue.Dequeue(), 1); circularQueue.Enqueue(2); circularQueue.Enqueue(3); Assert.AreEqual(circularQueue.Dequeue(), 2); Assert.AreEqual(circularQueue.Dequeue(), 3); circularQueue.Enqueue(4); circularQueue.Enqueue(5); circularQueue.Enqueue(6); circularQueue.Enqueue(7); Assert.AreEqual(circularQueue.Dequeue(), 4); Assert.AreEqual(circularQueue.Dequeue(), 5); Assert.AreEqual(circularQueue.Dequeue(), 6); Assert.AreEqual(circularQueue.Dequeue(), 7); circularQueue.Enqueue(8); circularQueue.Enqueue(9); Assert.AreEqual(circularQueue.Dequeue(), 8); circularQueue.Enqueue(10); Assert.IsFalse(circularQueue.IsEmpty); Assert.IsFalse(circularQueue.IsFull); circularQueue.Enqueue(11); circularQueue.Enqueue(12); Assert.IsFalse(circularQueue.IsEmpty); Assert.IsTrue(circularQueue.IsFull); Assert.AreEqual(circularQueue.Count, 4); Assert.AreEqual(circularQueue.Dequeue(), 9); Assert.AreEqual(circularQueue.Count, 3); Assert.AreEqual(circularQueue.Dequeue(), 10); Assert.AreEqual(circularQueue.Count, 2); Assert.AreEqual(circularQueue.Dequeue(), 11); Assert.AreEqual(circularQueue.Count, 1); Assert.AreEqual(circularQueue.Dequeue(), 12); Assert.IsFalse(circularQueue.IsFull); Assert.IsTrue(circularQueue.IsEmpty); Assert.AreEqual(circularQueue.Count, 0); }
public NetworkManager(IPAddress serverAddress, int serverPort) { this.serverAddress = serverAddress; this.serverPort = serverPort; this.balloonCache = new Dictionary<string, Balloon>(); this.messageQueue = new CircularQueue<Message>(256); m_conn = new ScreenConnection(this.messageQueue); m_conn.Connected += OnConnected; m_conn.ConnectFailed += OnConnectFailed; m_conn.Disconnected += OnDisconnected; m_conn.MessageReceived += OnMessageReceived; }
public static CircularQueue<Location> LoadFile(string filePath) { if (!File.Exists(filePath)) throw new FileNotFoundException("Could not find the specified file!", filePath); var ret = new CircularQueue<Location>(); XElement file = XElement.Load(filePath); var points = from p in file.Descendants("Location") select p; foreach (XElement point in points) ret.Enqueue(new Location(point)); return ret; }
public Server(int port) { m_port = port; m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); m_queue = new CircularQueue<Message>(64); m_nextScreenID = 0; m_nextBalloonID = 0; m_screens = new List<Screen>(); m_bubbles = new Dictionary<int, ServerBalloon>(); m_reader = new FeedReader(this, "http://localhost", 1000); //m_reader.Start(); m_random = new Random(); }
/// <summary> /// Remove all items *not* in a supplied collection from this bag, /// counting multiplicities. /// </summary> /// <param name="items">The items to retain</param> public virtual void RetainAll(SCG.IEnumerable <T> items) { updatecheck(); HashBag <T> res = new HashBag <T>(itemequalityComparer); foreach (T item in items) { KeyValuePair <T, int> p = new KeyValuePair <T, int>(item); if (dict.Find(ref p)) { KeyValuePair <T, int> q = p; if (res.dict.Find(ref q)) { if (q.Value < p.Value) { q.Value++; res.dict.Update(q); res.size++; } } else { q.Value = 1; res.dict.Add(q); res.size++; } } } if (size == res.size) { return; } CircularQueue <T> wasRemoved = null; if ((ActiveEvents & EventTypeEnum.Removed) != 0) { wasRemoved = new CircularQueue <T>(); foreach (KeyValuePair <T, int> p in dict) { int removed = p.Value - res.ContainsCount(p.Key); if (removed > 0) { //#warning We could send bag events here easily using a CircularQueue of (should?) for (int i = 0; i < removed; i++) { wasRemoved.Enqueue(p.Key); } } } } dict = res.dict; size = res.size; if ((ActiveEvents & EventTypeEnum.Removed) != 0) { raiseForRemoveAll(wasRemoved); } else if ((ActiveEvents & EventTypeEnum.Changed) != 0) { raiseCollectionChanged(); } }
static void Main() { var queue = new CircularQueue <int>(); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); queue.Enqueue(6); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); var first = queue.Dequeue(); Console.WriteLine("First = {0}", first); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); queue.Enqueue(-7); queue.Enqueue(-8); queue.Enqueue(-9); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); first = queue.Dequeue(); Console.WriteLine("First = {0}", first); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); queue.Enqueue(-10); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); first = queue.Dequeue(); Console.WriteLine("First = {0}", first); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); queue.Enqueue(-7); queue.Enqueue(-8); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); queue.Enqueue(-9); Console.WriteLine("Count = {0}", queue.Count); Console.WriteLine(string.Join(", ", queue.ToArray())); Console.WriteLine("---------------------------"); Console.Read(); }
public void zero_capacity_queue_is_empty() { var q = new CircularQueue <int>(0); Assert.IsTrue(q.Empty); }
/// <summary> /// Initializes a new instance of the <see cref="RewardCalculator"/> class. /// </summary> /// <param name="type">The type.</param> private RewardCalculator(RewardCalculatorType type) { Type = type; Winnings = new CircularQueue <double>(14); Loosings = new CircularQueue <double>(14); }
public void CircularQueueWithCapacity1ThrowsContractException() { var sut = new CircularQueue <string>(1); }
public void NextOnEmpty() { CircularQueue <string> circularQueue = new CircularQueue <string>(); circularQueue.Next(); }
static void Main(string[] args) { #region 1. Two Sum TwoSums twoSums = new TwoSums(new int[] { 2, 7, 11, 15 }, 18); twoSums.PrintExample(); #endregion #region 3. LongestSubstringWithoutRepeatingCharacters LongestSubstringWithoutRepeatingCharacters longestSubstringWithoutRepeating = new LongestSubstringWithoutRepeatingCharacters("abcdecb"); longestSubstringWithoutRepeating.PrintExample(); #endregion #region 7. Reverse Integer ReverseInteger reverseInteger = new ReverseInteger(-54321); reverseInteger.PrintExample(); #endregion #region 8. String to Integer (atoi) StringToInteger stringToInteger = new StringToInteger(" -42"); stringToInteger.PrintExample(); #endregion #region 9. Palindrome Number PalindromeNumber palindromeNumber = new PalindromeNumber(121); palindromeNumber.PrintExample(); #endregion #region 20. Valid Parentheses ValidParentheses validParentheses = new ValidParentheses("(){[]}"); validParentheses.PrintExample(); #endregion #region 26. Remove Duplicates from Sorted Array RemoveDuplicatesFromSortedArray removeDuplicatesFromSortedArray = new RemoveDuplicatesFromSortedArray(new [] { 1, 2, 3, 3, 4, 5, 5, 5, 5, 5, 5, 6 }); removeDuplicatesFromSortedArray.PrintExample(); #endregion #region 35. Search Insert Position SearchInsertPosition searchInsertPosition = new SearchInsertPosition(new [] { 1, 3, 5, 10 }, 9); searchInsertPosition.PrintExample(); #endregion #region 58. Length of Last Word LengthOfLastWord lengthOfLastWord = new LengthOfLastWord("Hello World"); lengthOfLastWord.PrintExample(); #endregion #region 104. Maximum Depth of Binary Tree #endregion #region 125. Valid Palindrome ValidPalindrome validPalindrome = new ValidPalindrome("A man, a plan, a canal: Panama"); validPalindrome.PrintExample(); #endregion #region 136. Single Number SingleNumber singleNumber = new SingleNumber(new [] { 2, 2, 3, 3, 1 }); singleNumber.PrintExample(); #endregion #region 150. Evaluate Reverse Polish Notation EvaluateReversePolishNotation evaluateReversePolishNotation = new EvaluateReversePolishNotation(new [] { "2", "1", "+", "3", "*" }); evaluateReversePolishNotation.PrintExample(); #endregion #region 155. Min Stack MinStack minStack = new MinStack(); minStack.PrintExample(); #endregion #region 167. Two Sum II - Input array is sorted TwoSumII twoSumII = new TwoSumII(new [] { 1, 2, 3, 7 }, 10); twoSumII.PrintExample(); #endregion #region 200. Number of Islands NumberOfIslands numberOfIslands = new NumberOfIslands(new char[, ] { { '1', '1', '0', '0', '0' }, { '1', '1', '0', '0', '0' }, { '0', '0', '1', '0', '0' }, { '0', '0', '0', '1', '1' } }); numberOfIslands.PrintExample(); #endregion #region 217. Contains Duplicate ContainsDuplicate containsDuplicate = new ContainsDuplicate(new [] { 1, 2, 3, 1 }); containsDuplicate.PrintExample(); #endregion #region 268. Missing Number MissingNumber missingNumber = new MissingNumber(new [] { 9, 6, 4, 2, 3, 5, 7, 0, 1 }); missingNumber.PrintExample(); #endregion #region 344. Reverse String ReverseString reverseString = new ReverseString("A man with a plan"); reverseString.PrintExample(); #endregion #region 387. First Unique Character in a String FirstUniqueCharacterInAString firstUniqueChar = new FirstUniqueCharacterInAString("loveleetcode"); firstUniqueChar.PrintExample(); #endregion #region 412. FizzBuzz FizzBuzz fizzBuzz = new FizzBuzz(15); fizzBuzz.PrintExample(); #endregion #region 485. Max Consecutive Ones MaxConsecutiveOnes maxConsecutiveOnes = new MaxConsecutiveOnes(new int[] { 1, 1, 0, 1, 1, 1 }); maxConsecutiveOnes.PrintExample(); #endregion #region 509. Fibonacci Number FibonacciNumber fibonacciNumber = new FibonacciNumber(10); fibonacciNumber.PrintExample(); #endregion #region 622. Design Circular Queue CircularQueue circularQueue = new CircularQueue(1); Console.WriteLine("622. Design Circular Queue"); Console.WriteLine($"Front() : {circularQueue.Front()}"); Console.WriteLine($"IsEmpty() : {circularQueue.IsEmpty()}"); circularQueue.EnQueue(1); Console.WriteLine($"EnQueue(1)"); Console.WriteLine($"IsEmpty() : {circularQueue.IsEmpty()}"); Console.WriteLine($"IsFull() : {circularQueue.IsFull()}\n"); #endregion #region 707. Design Linked List LinkedList linkedList = new LinkedList(new Node()); linkedList.AddAtTail(10); linkedList.AddAtTail(20); linkedList.PrintLinkedList(); #endregion #region 709. To Lower Case ToLowerCase toLowerCase = new ToLowerCase("LOVELY"); toLowerCase.PrintExample(); #endregion #region 739. Daily Temperatures DailyTemperatures dailyTemperatures = new DailyTemperatures(new [] { 89, 62, 70, 58, 47, 47, 46, 76, 100, 70 }); dailyTemperatures.PrintExample(); #endregion #region 747. Largest Number at Least Twice of Others LargestNumberAtLeastTwiceOfOthers largestNumberAtLeastTwiceOfOthers = new LargestNumberAtLeastTwiceOfOthers(new [] { 3, 6, 1, 0 }); largestNumberAtLeastTwiceOfOthers.PrintExample(); #endregion #region 771. Jewels and Stones string j = "aA", s = "aAAbbbb"; JewelsAndStones jewelsAndStones = new JewelsAndStones(j, s); jewelsAndStones.PrintExample(); #endregion #region 832. Flipping an Image int[][] flippingImageArray = new int[3][]; flippingImageArray[0] = new int[] { 1, 1, 0 }; flippingImageArray[1] = new int[] { 1, 0, 1 }; flippingImageArray[2] = new int[] { 0, 0, 0 }; FlippingAnImage flippingAnImage = new FlippingAnImage(flippingImageArray); flippingAnImage.PrintExample(); #endregion #region 917. Reverse Only Letters ReverseOnlyLetters reverseOnlyLetters = new ReverseOnlyLetters("Qedo1ct-eeLg=ntse-T!"); reverseOnlyLetters.PrintExample(); #endregion Console.ReadLine(); }
public EnqueueOperation(CircularQueue queue) => this.queue = queue;
IEnumerator PlayAI() { int FrameCount = 0; CircularQueue <float[]> History = new CircularQueue <float[]>(); History.Init(m_nHistoryCount, new float[m_nInputSize]); UpdateStateBuffer(); for (int i = 0; i < m_nHistoryCount; i++) { History.pushBack(m_faStateBuffer); } double[] daInput = new double[m_nn.m_nInputSize]; double[] daNext_input = new double[m_nn.m_nInputSize]; double[] daReward = new double[m_nn.m_nOutputSize]; float[] HistoryData; WaitForEndOfFrame endofFrame = new WaitForEndOfFrame(); while (true) { for (int i = 0; i < m_nHistoryCount; i++) { History.getValue(i, out HistoryData); Array.Copy(HistoryData, 0, daInput, i * HistoryData.Length, HistoryData.Length); } m_nn.SetInput(daInput); m_nn.FeedForward(); int nSelected_dir = m_bTraning ? m_nn.GetOutputIXEpsilonGreedy(m_fTraningRandomValue) : m_nn.GetOutputIXEpsilonGreedy(0.0); m_scriptPaddle.Move((Paddle_2D.MoveDir)nSelected_dir); yield return(endofFrame); float fReward = m_scriptBall.m_fReward; if (fReward > 0.5f) { counter++; } if (fReward != 0.0f) { counter_all++; } //Debug.Log(counter_all); if (counter_all == 1000) { //static double time = timeGetTime(); //if (m_bTraning == true) //{ Debug.Log((float)counter / (float)counter_all * 100.0f); //} //std::cout << (float)counter / (float)counter_all * 100.0f << " % " << (timeGetTime() - time) / 1000.0f << " sec" << std::endl; //time = timeGetTime(); counter = 0; counter_all = 0; } //Debug.Log("FrameCount: " + ++FrameCount + " Reward: " + fReward); //if (fReward < 0.0f) //{ // fReward = 0.0f; //} m_scriptBall.m_fReward = 0; m_nn.copyOutputVectorTo(ref daReward); History.pushBack(UpdateStateBuffer().Clone() as float[]); for (int i = 0; i < m_nHistoryCount; i++) { History.getValue(i, out HistoryData); Array.Copy(HistoryData, 0, daNext_input, i * HistoryData.Length, HistoryData.Length); } m_nn.SetInput(daNext_input); m_nn.FeedForward(); double?dNext_Q = m_nn.GetMaxValueFromOutput(); if (dNext_Q.HasValue) { daReward[nSelected_dir] = fReward + (m_fGamma * dNext_Q.Value); } if (m_bTraning) { if (fReward > 0) { m_nn.SetInput(daInput); for (int i = 0; i < 20; i++) { m_nn.FeedForward(); m_nn.PropBackward(daReward); } } } m_nn.SetInput(daInput); m_nn.FeedForward(); m_nn.PropBackward(daReward); } }
public void CannotCreateQueueSmallerThan2_Test() { CircularQueue <string> failure = new CircularQueue <string>(1); }
public void CanConstruct_Test() { CircularQueue <string> queue = new CircularQueue <string>(5); Assert.IsInstanceOfType(queue, typeof(CircularQueue <string>)); }
public void IsEmpty_EmptyQueue_ReturnsTrue() { var stack = new CircularQueue <int>(); Assert.IsTrue(stack.IsEmpty); }
public void TestInitialCount() { CircularQueue <int> queue = new CircularQueue <int>(10); Assert.AreEqual(0, queue.Count); }
public void ExceptionNullVisitor() { var circularQueue = new CircularQueue <int>(20); Assert.Throws <ArgumentNullException>(() => circularQueue.AcceptVisitor(null)); }
public void AddItemToReadonly() { CircularQueue <string> circularQueue = new CircularQueue <string>(new[] { "First", "Second", "Third" }, true); circularQueue.Enqueue("First"); }
public void IsEmptyReturnsTrueOnEmptyQueue() { var Queue = new CircularQueue <string>(2); Assert.IsTrue(Queue.IsEmpty()); }
public void PeekOnEmpty() { CircularQueue <string> circularQueue = new CircularQueue <string>(); circularQueue.Peek(); }
public void QueueStackCorrectlyReportsItsEmptiness() { var sut = new CircularQueue <int>(); Assert.True(sut.IsEmpty); }
public void RemoveOnEmpty() { CircularQueue <string> circularQueue = new CircularQueue <string>(); circularQueue.Remove(); }
public void PopFromEmptyQueueThrowsAnException() { var sut = new CircularQueue <int>(); Assert.Throws <ArgumentException>(() => sut.Dequeue()); }
protected void UnLoadInput() { _circularQueue = new CircularQueue <int>(); }
public void CanEnqueueOneElement() { var Queue = new CircularQueue <string>(10); Queue.Enqueue(_elements[0]); }
public void CircularQueueWithCapacity4096Succeeds() { var sut = new CircularQueue <string>(4096); }
public void ExceptionNullVisitor() { var circularQueue = new CircularQueue <int>(20); circularQueue.AcceptVisitor(null); }
public ExecutionContext() { ValueStack = new CircularQueue <byte[]>(); AltStack = new CircularQueue <byte[]>(); ControlStack = new CircularQueue <bool>(); }
public MainForm() { log4net.Config.XmlConfigurator.Configure(); log.Info("MainForm.MainForm : Application opened as " + PROGRAM_NAME); InitializeComponent(); this.Text = PROGRAM_NAME; isCameraMode = false; zibReplayCam1.SetText(""); zibReplayCam2.SetText(""); Camera1Display.SetText(""); Camera2Display.SetText(""); SwitchDisplayMode(); guiSem = new Semaphore(0, 1); program_settings = new Settings(); // see how much memory is available on computer and take 80% of it float freeMem = 1000; try { System.Diagnostics.PerformanceCounter ramCounter = new System.Diagnostics.PerformanceCounter("Memory", "Available MBytes"); freeMem = ramCounter.NextValue(); } catch (Exception inner) { log.Error("MainForm.Form1_Load : Unable to retrieve amount of free memory on system, defaulting to 1GB.", inner); } if (freeMem > 2100) { freeMem = 2100; } // each queue takes 6 MB per item in it int queueSize = 50;//Convert.ToInt32(freeMem * 0.90) / 32; mainQueue = new CircularQueue <QueueElement>("MAIN", queueSize); ipQueue1 = new CircularQueue <QueueElement>("IP1", queueSize); ipQueue2 = new CircularQueue <QueueElement>("IP2", queueSize); saveQueue = new CircularQueue <QueueElement>("save_queue", queueSize); // initialize camera and processor 1 cam1 = new Camera(); cam1.AddSubscriber(ipQueue1); cam1.AddSubscriber(mainQueue); imagep1 = new FailureDetector(DEFAULT_IMAGE_PROCESSOR1_NAME, ref cam1); imagep1.SetConsumerQueue(ipQueue1); imagep1.AddSubscriber(saveQueue); imagep1.AddSubscriber(mainQueue); imagep1.EnableAutoExposure(true); imagep1.EnableAutoROI(false); // initialize camera and processor 2 cam2 = new Camera(); cam2.AddSubscriber(ipQueue2); cam2.AddSubscriber(mainQueue); imagep2 = new FailureDetector(DEFAULT_IMAGE_PROCESSOR2_NAME, ref cam2); imagep2.SetConsumerQueue(ipQueue2); imagep2.AddSubscriber(saveQueue); imagep2.AddSubscriber(mainQueue); imagep2.EnableAutoExposure(true); imagep2.EnableAutoROI(false); // sets image queue saveEngine = new ImageHistoryBuffer(); saveEngine.SetConsumerQueue(saveQueue); // add thread error handlers cam1.ThreadError += new ThreadErrorHandler(Camera0ThreadError); cam2.ThreadError += new ThreadErrorHandler(Camera1ThreadError); imagep1.ThreadError += new ThreadErrorHandler(ImageProcessor0ThreadError); imagep2.ThreadError += new ThreadErrorHandler(ImageProcessor0ThreadError); saveEngine.ThreadError += new ThreadErrorHandler(SaveQueueThreadError); // start the cameras RefreshCameras(); // initialize camera and processor periods camera1Period = 0.066; camera2Period = 0.066; process1Period = 0.2; process2Period = 0.2; // need to update comboboxes cmboCam1View.Items.Add(DISPLAY_TYPE_NORMAL); cmboCam1View.Items.Add(DISPLAY_TYPE_PROCESSED); cmboCam1View.SelectedIndex = 0; cmboCam2View.Items.Add(DISPLAY_TYPE_NORMAL); cmboCam2View.Items.Add(DISPLAY_TYPE_PROCESSED); cmboCam2View.SelectedIndex = 0; cmbo_DataType.Items.Add(DISPLAY_TYPE_NORMAL); cmbo_DataType.Items.Add(DISPLAY_TYPE_PROCESSED); cmbo_DataType.SelectedIndex = 1; cmbo_VideoType.Items.Add(VIDEO_TYPE_TEST); cmbo_VideoType.Items.Add(VIDEO_TYPE_DEBUG); cmbo_VideoType.SelectedIndex = 0; cmbo_DataType.SelectedIndexChanged += cmbo_DataType_SelectedIndexChanged; cmbo_VideoType.SelectedIndexChanged += cmbo_VideoType_SelectedIndexChanged; isReplayManagerValid = false; guiSem.Release(); // setup timer update TimerCallback tcb = new TimerCallback(DisplayImage); imageUpdateTimer = new System.Threading.Timer(tcb, imageUpdateTimer, Timeout.Infinite, Timeout.Infinite); imageUpdateTimer.Change(1, 200); // setup garbage collector TimerCallback tcb2 = new TimerCallback(GarbageCollector); garbageCollector = new System.Threading.Timer(tcb2, garbageCollector, Timeout.Infinite, Timeout.Infinite); garbageCollector.Change(1, 100); // setup replay feedback TimerCallback tcb3 = new TimerCallback(ReplayFeedbackTimer); replayFeedbackTimer = new System.Threading.Timer(tcb3, replayFeedbackTimer, Timeout.Infinite, Timeout.Infinite); }
/// <summary> /// Retrieves the consumer queue from the Failure Detector. Add /// ImageData to this queue in order to get the image processed. /// </summary> /// <returns>Consumer Queueu</returns> public void SetConsumerQueue(CircularQueue <QueueElement> consumer) { consumerQueue = consumer; }
public void ExceptionEmpty() { var circularQueue = new CircularQueue <int>(20); circularQueue.Peek(); }
public void ExceptionEmpty() { var circularQueue = new CircularQueue <int>(40); circularQueue.Dequeue(); }
public void ExceptionNullArray() { var circularQueue = new CircularQueue <int>(20); circularQueue.CopyTo(null, 0); }