예제 #1
0
        public static double ProveriMatematickiIzrazIliStaVec(string test)
        {
            StackList <string> stack = new StackList <string>();
            int i = 0;

            try {
                for (i = 0; i < test.Length; ++i)
                {
                    if (test[i] == ')')
                    {
                        double drugi = Double.Parse(stack.Top);
                        stack.Pop();
                        char operacija = stack.Top[0];
                        stack.Pop();
                        double prvi = Double.Parse(stack.Top);
                        stack.Pop();
                        stack.Pop();
                        stack.Push(izracunaj(prvi, drugi, operacija).ToString());
                    }
                    else
                    {
                        stack.Push("" + test[i]);
                    }
                }
            }
            catch (Exception e) { throw e; }
            return(Double.Parse(stack.Top));
        }
        public bool SyntaxError(lr_parser parser, Symbol curToken)
        {
            TypeCobolProgramParser tcpParser = parser as TypeCobolProgramParser;

            if (tcpParser.IsTrial)
            {
                return(true);
            }
            List <string> expected    = ExpectedSymbols(parser, curToken);
            string        symName     = CodeElementTokenizer.CupTokenToString(curToken.sym);
            Symbol        validSymbol = GetParserValidStackSymbol(parser, curToken);
            string        text        = validSymbol != null ? (validSymbol.value as CodeElement).Text : "";
            string        msg         = string.Format("extraneous input '{0}' expecting {{{1}}}", text, string.Join(", ", expected));

            System.Diagnostics.Debug.WriteLine(msg);
            CupParserDiagnostic diagnostic = new CupParserDiagnostic(msg, validSymbol, null);

            AddDiagnostic(diagnostic);
            //Try to add the last encountered statement in the stack if it is not already entered.
            StackList <Symbol> stack = tcpParser.getParserStack();

            foreach (var symbol in stack)
            {
                if (symbol.value is StatementElement)
                {
                    lr_parser stmtParser = CloneParser(parser, TypeCobolProgramSymbols.StatementEntryPoint,
                                                       symbol.value as CodeElement, true);
                    stmtParser.parse();
                    break;
                }
            }
            return(true);
        }
예제 #3
0
        public static T DepthFirstSearch <T>(this Graph <T> graph, Func <T, bool> matchFunc)
            where T : class
        {
            if (graph.IsEmpty)
            {
                return(null);
            }

            graph.Nodes.ForEach(x => x._isVisited = false);

            IStack <GraphNode <T> > queue = new StackList <GraphNode <T> >();

            queue.Push(graph.Nodes[0]);

            while (!queue.IsEmpty)
            {
                var node = queue.Pop();
                if (node._isVisited)
                {
                    continue;
                }

                if (matchFunc(node.Data))
                {
                    return(node.Data);
                }

                node.Edges.ForEach(x => queue.Push(x.To));
                node._isVisited = true;
            }

            return(null);
        }
예제 #4
0
            internal SpanSplitSequenceEnumerator(ReadOnlySpan <T> span, ReadOnlySpan <T> separator, StringSplitOptions stringSplitOptions)
            {
                Sequence     = span;
                SplitOptions = stringSplitOptions;

                var separatorIndices = new StackList <int>(2);

                SeparatorLength = separator.Length;

                //https://github.com/dotnet/runtime/blob/master/src/libraries/System.Private.CoreLib/src/System/String.Manipulation.cs#L1579
                for (int i = 0; i < span.Length; ++i)
                {
                    if (span[i].Equals(separator[0]) && SeparatorLength <= span.Length - i)
                    {
                        if (SeparatorLength == 1 || span.Slice(i, SeparatorLength).SequenceEqual(separator))
                        {
                            separatorIndices.Append(i);
                            i += SeparatorLength - 1;
                        }
                    }
                }
                SeparatorIndices = separatorIndices;

                Index          = 0;
                SeparatorIndex = 0;
                StartIndex     = 0;
                Offset         = 0;
            }
예제 #5
0
        private IReadOnlyCollection <FlowComponent> getIdListRegionComponents()
        {
            var components = new List <FlowComponent>();

            var rs = new UpdateRegionSet();

            components.Add(
                new LineList(
                    new EwfButton(
                        new StandardButtonStyle("Add Item"),
                        behavior: new PostBackBehavior(
                            postBack: PostBack.CreateIntermediate(
                                rs.ToCollection(),
                                id: "idAdd",
                                firstModificationMethod: () =>
                                parametersModification.ItemIds = (parametersModification.ItemIds.Any() ? parametersModification.ItemIds.Min() - 1 : 0).ToCollection()
                                                                 .Concat(parametersModification.ItemIds)))).ToCollection()
                    .ToComponentListItem()
                    .ToLineListItemCollection()));

            var stack = new StackList(
                info.ItemIds.Select(getIdItem),
                setup: new ComponentListSetup(
                    itemInsertionUpdateRegions: new ItemInsertionUpdateRegion(rs.ToCollection(), () => parametersModification.ItemIds.First().ToString().ToCollection())
                    .ToCollection()));

            components.Add(new Section("Control List With ID Items", stack.ToCollection(), style: SectionStyle.Box));
            return(components);
        }
예제 #6
0
 internal Enumerator(StackList <T> stack)
 {
     _stack          = stack;
     _version        = stack._version;
     _index          = -2;
     _currentElement = default;
 }
예제 #7
0
            public void DefaultConstructorTest()
            {
                Stack stack = new StackList();
                var   list  = getList(stack);

                Assert.IsNotNull(list);
            }
예제 #8
0
 internal BTreeClass(int order)
 {
     Order    = order;
     HalfFull = (order - 1) / 2;
     Root     = new BTreeNode(order);
     Stack    = new StackList();
     Stack.Add(new StackItem());
 }
예제 #9
0
 /// <summary>
 /// Determines if the given token has been consumed. A token is consumed if it is
 /// present on the parser stack.
 /// </summary>
 /// <param name="parser">The parser</param>
 /// <param name="stack">The parser stack</param>
 /// <param name="curToken">The Token to check</param>
 /// <returns>true if the token is consumed, false otherwise</returns>
 public bool IsTokenConsumed(lr_parser parser, StackList <Symbol> stack, Symbol curToken)
 {
     if (curToken?.value == null)
     {
         return(false);
     }
     return(stack.Contains(curToken));
 }
예제 #10
0
        public void test_add_to_stack()
        {
            StackList <string> stack = new StackList <string>();

            stack.Push("world");

            Assert.AreEqual(1, stack.Count);
        }
        public override bool SyntaxError(lr_parser parser, StackList <Symbol> stack, Symbol curToken)
        {
            LastMismatchedSymbol = null;
            bool bResult = base.SyntaxError(parser, stack, curToken);

            ((CobolWordsTokenizer)parser.getScanner()).EnterStopScanningMode();
            ((CobolWordsTokenizer)parser.getScanner()).RevertLastToken(LastMismatchedSymbol);
            return(bResult);
        }
예제 #12
0
        /// <summary>
        /// Returns the number of steps needed to change the contents of <paramref name="span"/> into <paramref name="other"/>.
        /// </summary>
        /// <param name="sourceRunes">The first text instance.</param>
        /// <param name="otherRunes">The second text instance.</param>
        /// <param name="comparison">How to compare two chars.</param>
        /// <returns>The number of steps needed to change <paramref name="span"/> into <paramref name="other"/>.</returns>
        /// <exception cref="NotImplementedException">The specified comparison is not implemented between two Runes with different ordinal values.</exception>
        private static int DamerauLevenshteinDistance(ref StackList <Rune> sourceRunes, ref StackList <Rune> otherRunes, StringComparison comparison = StringComparison.Ordinal)
        {
            int spanLength  = sourceRunes.Length;
            int otherLength = otherRunes.Length;

            if (spanLength == 0)
            {
                return(otherLength);
            }

            if (otherLength == 0)
            {
                return(spanLength);
            }

            // Finding distances here utilizes a sort of grid. We use that as a lookup for our real word count.
            var costs = new Array2D <int>(stackalloc int[(spanLength + 1) * (otherLength + 1)], spanLength + 1, otherLength + 1);

            for (int x = 0; x <= spanLength; costs[x, 0] = x++)
            {
                ;
            }
            for (int y = 0; y <= otherLength; costs[0, y] = y++)
            {
                ;
            }

            for (int x = 1; x <= spanLength; ++x)
            {
                for (int y = 1; y <= otherLength; ++y)
                {
                    var sourceRune = sourceRunes[x - 1];
                    var otherRune  = otherRunes[y - 1];

                    int cost         = RunesEqual(sourceRune, otherRune, comparison) ? 0 : 1;
                    int insertion    = costs[x, y - 1] + 1;
                    int deletion     = costs[x - 1, y] + 1;
                    int substitution = costs[x - 1, y - 1] + cost;

                    int distance = insertion.Min(deletion, substitution);

                    if (x > 1 && y > 1 &&
                        RunesEqual(sourceRunes[x - 1], otherRunes[y - 2], comparison) &&
                        RunesEqual(sourceRunes[x - 2], otherRunes[y - 1], comparison))
                    {
                        distance = Math.Min(distance, costs[x - 2, y - 2] + cost);
                    }

                    costs[x, y] = distance;
                }
            }

            return(costs[spanLength, otherLength]);
        }
예제 #13
0
        public void test_remove_to_stack()
        {
            StackList <string> stack = new StackList <string>();

            stack.Push("world");
            stack.Push("ocean");

            var value = stack.Pop();

            Assert.AreEqual("ocean", value);
        }
예제 #14
0
        //--------
        public override string ToString()
        {
            BluetoothStackConfigElement[] arr = new BluetoothStackConfigElement[StackList.Count];
            StackList.CopyTo(arr, 0);
            string slConcat = "{" + string.Join(", ", Array.ConvertAll <BluetoothStackConfigElement, string>(arr,
                                                                                                             delegate(BluetoothStackConfigElement inp) { return((inp == null) ? "(null)" : inp.Name); })) + "}";

            //
            return(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                                 "[BluetoothFactorySection: OneStackOnly: {0}, ReportAllErrors: {1}, StackList: {2}, FooBar1: {3}]",
                                 this.OneStackOnly, this.ReportAllErrors, slConcat, this.FooBar1));
        }
예제 #15
0
        public void test_remove_empty()
        {
            StackList <string> stack = new StackList <string>();

            stack.Push("world");
            stack.Push("ocean");

            stack.Pop();
            stack.Pop();

            Assert.AreEqual(0, stack.Count);
        }
예제 #16
0
        /// <summary>
        /// 构造拓扑排序对象
        /// </summary>
        /// <param name="g">有向图</param>
        public TopoLogicalOrder(GraphDigraph g)
        {
            // 检测图是否有环
            GraphDirectedCyle cycle = new GraphDirectedCyle(g);
            bool hasCycle           = cycle.hasCycle();

            if (!hasCycle)
            {
                DepthFirstOrder depth = new DepthFirstOrder(g);
                orderStack = depth.reversePost();
            }
        }
        public TData Search(float?costDepthLimit = null)
        {
            NextCostThreshhold = float.MaxValue;

            IStack <TreeNode <TData> > stack = new StackList <TreeNode <TData> >();

            stack.Push(_tree.Root);

            while (!stack.IsEmpty)
            {
                CurrentNode = stack.Pop();

                if (_matchFunc(CurrentNode.Data))
                {
                    return(CurrentNode.Data);
                }

                var actions = _actionsListFunc(CurrentNode.Data);

                CurrentNode.Children = new List <TreeNode <TData> >();
                foreach (var action in actions)
                {
                    var newNode = new TreeNode <TData>
                    {
                        Parent = CurrentNode,
                        Data   = _actionApplierFunc(CurrentNode.Data, action),
                        Cost   = CurrentNode.Cost + _actionCostFunc(CurrentNode.Data, action)
                    };
                    CurrentNode.Children.Add(newNode);
                }

                // Load new children onto stack
                CurrentNode.Children.ForEach(x =>
                {
                    if (costDepthLimit == null || costDepthLimit.Value >= x.Cost)
                    {
                        stack.Push(x);
                    }
                    else if (x.Cost < NextCostThreshhold)
                    {
                        NextCostThreshhold = x.Cost;
                    }
                });

                // Update counts & notifications
                OnNodeExpanded();
                CurrentNode.Children.ForEach(x => OnNodeGenerated());
                NodesRetainedCount = stack.Count;
            }

            return(null);
        }
예제 #18
0
        public static void TraverseDepthFirst <T>(this SearchTree <T> tree, Action <T> action)
            where T : class
        {
            IStack <TreeNode <T> > stack = new StackList <TreeNode <T> >();

            stack.Push(tree.Root);
            while (!stack.IsEmpty)
            {
                var node = stack.Pop();
                action(node.Data);
                node.Children.ForEach(stack.Push);
            }
        }
예제 #19
0
파일: StackView.cs 프로젝트: mono/emveepee
 public StackView(ProfileData data, DisplayOptions options)
 {
     list = new StackList (data, options);
     ScrolledWindow sw = new ScrolledWindow ();
     sw.Add (list);
     sw.ShowAll ();
     Add1 (sw);
     detail = new StackDetail (data, options);
     detail.CurrentItem = list.SelectedItem;
     list.Selection.Changed += delegate { detail.CurrentItem = list.SelectedItem; };
     Add2 (detail);
     Position = 200;
 }
예제 #20
0
        public CommandLine(string assetname) :
            base(assetname)
        {
            if (TextFont != null)
            {
                TextFont.Color = Color.White;
            }

            vc = new StackList <char>();
            ac = new StackList <char>();

            acursor = cursor;
            timer   = 0.5f;
        }
예제 #21
0
        public object Pop()
        {
            if (StackList.Count() == 0)
            {
                throw new InvalidOperationException();
            }

            else
            {
                object temp = StackList[StackList.Count() - 1];
                StackList.Remove(StackList[StackList.Count() - 1]);
                return(temp);
            }
        }
예제 #22
0
 public override void Clear()
 {
     if (StackList != null)
     {
         for (int i = 0; i < StackList.Count; i++)
         {
             if (StackList[i] != null)
             {
                 StackList[i].Clear();
             }
         }
         StackList.Clear();
     }
 }
예제 #23
0
            public void PeekTest()
            {
                Stack stack = new StackList();

                Assert.IsNull(stack.Peek());

                stack.Push(5);
                Assert.AreEqual(5, stack.Peek());
                Assert.AreEqual(5, stack.Peek());

                stack.Push(7);
                Assert.AreEqual(7, stack.Peek());
                Assert.AreEqual(7, stack.Peek());
            }
예제 #24
0
 /// <summary>
 /// 创建一个顶点排序对象 生成顶点线性队列
 /// </summary>
 /// <param name="g"></param>
 public DepthFirstOrder(GraphDigraph g)
 {
     // 初始markeds 数组
     this.markeds = new bool[g.countV()];
     // 初始化 reversePost stack 栈
     this.reversePostStack = new StackList <int>();
     // 遍历图中的每一个顶点,让每一个定点做作为入口,完成一次深度优先搜索
     for (int v = 0; v < g.countV(); v++)
     {
         if (!this.markeds[v])
         {
             dfs(g, v);
         }
     }
 }
예제 #25
0
            public void PushTest()
            {
                Stack stack = new StackList();

                stack.Push(3);
                stack.Push(5);
                stack.Push(7);

                var outputStack = getList(stack);

                Assert.AreEqual(3, outputStack.Count);
                Assert.AreEqual(7, outputStack.First());
                Assert.AreEqual(7, outputStack[0]);
                Assert.AreEqual(5, outputStack[1]);
                Assert.AreEqual(3, outputStack[2]);
            }
예제 #26
0
        /// <summary>
        /// Makes a string from a stacklist.
        /// </summary>
        /// <param name="c">The stacklist.</param>
        /// <param name="back">The direction the stacklist needs to be read.</param>
        /// <returns></returns>
        private string StackToString(StackList <char> c, bool back = false)
        {
            string s = "";

            for (int i = 0; i < c.Count; i++)
            {
                if (!back)
                {
                    s = c[i] + s;
                }
                else
                {
                    s += c[i];
                }
            }
            return(s);
        }
예제 #27
0
        /*-----------------------------------------------------------*/
        /*--- Constructor(s) ----------------------------------------*/
        /*-----------------------------------------------------------*/

        /** Constructor to build a virtual stack out of a real stack. */
        public virtual_parse_stack(StackList <Symbol> shadowing_stack)
        {
            /* sanity check */
            if (shadowing_stack == null)
            {
                throw new System.Exception(
                          "Internal parser error: attempt to create null virtual stack");
            }

            /* Set up our internals */
            real_stack = shadowing_stack;
            vstack     = new Stack <int>();
            real_next  = 0;

            /* get one element onto the virtual portion of the stack */
            get_from_real();
        }
예제 #28
0
        /// <summary>
        /// 栈 测试
        /// </summary>
        private static void StackListTest()
        {
            StackList <Student> list = new StackList <Student>();

            for (int i = 0; i < 5; i++)
            {
                list.push(new Student()
                {
                    cardID = i, name = "sun" + i
                });
            }
            Console.WriteLine("StackList Length: " + list.length());
            IEnumerator tor = list.GetEnumerator();

            while (tor.MoveNext())
            {
                if (tor.Current is Student)
                {
                    Student s = tor.Current as Student;
                    Console.WriteLine("cardID: " + s.cardID);
                }
                else
                {
                    Console.WriteLine("LinkList GetEnumerator is null.");
                }
            }
            Student popStu = list.pop();

            Console.WriteLine("StackList pop Stu: " + popStu.cardID);
            Console.WriteLine("StackList Length: " + list.length());
            IEnumerator tor1 = list.GetEnumerator();

            while (tor1.MoveNext())
            {
                if (tor1.Current is Student)
                {
                    Student s = tor1.Current as Student;
                    Console.WriteLine("cardID: " + s.cardID);
                }
                else
                {
                    Console.WriteLine("LinkList GetEnumerator is null.");
                }
            }
        }
예제 #29
0
        /// <summary>
        /// Get the first valid Symbol on the parser stack having a value.
        /// </summary>
        /// <param name="parser">The parser stack</param>
        /// <param name="curToken">The current Symbol</param>
        /// <returns>The first valid symbol if any, null otherwise</returns>
        protected virtual Symbol GetParserValidStackSymbol(lr_parser parser, StackList <Symbol> stack, Symbol curToken)
        {
            if (curToken != null && curToken.value != null)
            {
                return(curToken);
            }
            //lookback in the stack to find a Symbol having a valid value.
            Symbol lastValid = null;

            foreach (Symbol s in stack)
            {//The first one will be the top of the stack wil be the last symbol encountered
                if (s.value != null)
                {
                    lastValid = s;
                    break;
                }
            }
            return(lastValid);
        }
예제 #30
0
        public StackList <int> pathTo(int v)
        {
            if (!hasPathTo(v))
            {
                return(null);
            }

            // 创建栈对象 保存路径中的所有顶点
            StackList <int> path = new StackList <int>();

            // 通过循环从顶点v开始一直往前找,知道找到起点
            for (int x = v; x != this.s; x = edgeTo[x])
            {
                path.push(x);
            }
            // 把起点s放进去
            path.push(this.s);
            return(path);
        }
        /// <summary>
        /// Get the first valid Symbol on the parser stack having a value.
        /// </summary>
        /// <param name="parser">The parser stack</param>
        /// <param name="curToken">The current Symbol</param>
        /// <returns>The first valid symbol if any, null otherwise</returns>
        private static Symbol GetParserValidStackSymbol(lr_parser parser, Symbol curToken)
        {
            if (curToken.value != null)
            {
                return(curToken);
            }
            //lookback in the stack to find a Symbol having a valid value.
            StackList <Symbol> stack     = ((TypeCobolProgramParser)parser).getParserStack();
            Symbol             lastValid = null;

            foreach (Symbol s in stack)
            {
                if (s.value != null)
                {
                    lastValid = s;
                }
            }
            return(lastValid);
        }
예제 #32
0
 void Start()
 {
     // Get Inventory's references
     InventoryManager inventory = Inventory.Finder.GetInventory();
     pickupsRef = inventory.GetStack();
     itemCountRef = inventory.GetItemCount();
 }